diff options
Diffstat (limited to 'source/slang')
22 files changed, 13019 insertions, 1335 deletions
diff --git a/source/slang/slang-ast-dump.cpp b/source/slang/slang-ast-dump.cpp index 7dba55c52..96a0afe6d 100644 --- a/source/slang/slang-ast-dump.cpp +++ b/source/slang/slang-ast-dump.cpp @@ -651,6 +651,9 @@ struct ASTDumpContext case SPIRVAsmOperand::Id: m_writer->emit("%"); break; + case SPIRVAsmOperand::ResultMarker: + m_writer->emit("result"); + break; case SPIRVAsmOperand::Literal: case SPIRVAsmOperand::NamedValue: break; diff --git a/source/slang/slang-ast-expr.h b/source/slang/slang-ast-expr.h index 36d304a1a..7b09c3334 100644 --- a/source/slang/slang-ast-expr.h +++ b/source/slang/slang-ast-expr.h @@ -6,6 +6,8 @@ namespace Slang { +using SpvWord = uint32_t; + // Syntax class definitions for expressions. // // A placeholder for where an Expr is expected but is missing from source. @@ -640,14 +642,38 @@ public: { Literal, // No prefix Id, // Prefixed with % - NamedValue, // An identifier + ResultMarker, // "result" (without quotes) + NamedValue, // Any other identifier SlangValue, SlangValueAddr, SlangType, }; + + // The flavour and token describes how this was parsed Flavor flavor; + // The single token this came from Token token; + + // If this was a SlangValue or SlangValueAddr or SlangType, then we also + // store the expression, which should be a single VarExpr because we only + // parse single idents at the moment Expr* expr = nullptr; + + // If this is part of a bitwise or expression, this will point to the + // remaining operands values in such an expression must be of flavour + // Literal or NamedValue + List<SPIRVAsmOperand> bitwiseOrWith = List<SPIRVAsmOperand>(); + + // If this is a named value then we calculate the value here during + // checking. If this is an opcode, then the parser will populate this too + // (or set it to 0xffffffff); + SpvWord knownValue = 0xffffffff; + // Although this might be a constant in the source we should actually pass + // it as an id created with OpConstant + bool wrapInId = false; + + // Once we've checked things, the SlangType flavour operands will have this + // type populated. TypeExp type = TypeExp(); }; diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp index 5266f02f6..43db85e3b 100644 --- a/source/slang/slang-check-expr.cpp +++ b/source/slang/slang-check-expr.cpp @@ -3898,44 +3898,114 @@ namespace Slang Expr* SemanticsExprVisitor::visitSPIRVAsmExpr(SPIRVAsmExpr* expr) { + // + // Firstly, get the info for this op, the opcode has already been + // discovered by the parser + // + const auto& spirvInfo = getSession()->spirvCoreGrammarInfo; + // We will iterate over all the operands in all the insts and check // them + bool failed = false; for(auto& inst : expr->insts) { + // It's not automatically a failure to not have info, we just won't + // be able to deduce types for operands + const auto opInfo = spirvInfo->opInfos.lookup(SpvOp(inst.opcode.knownValue)); + + if(opInfo->numOperandTypes == 0 && inst.operands.getCount()) + { + failed = true; + getSink()->diagnose(inst.opcode.token, Diagnostics::spirvInstructionWithTooManyOperands, inst.opcode.token, 0); + continue; + } + const bool isLast = &inst == &expr->insts.getLast(); - for(auto& operand : inst.operands) + for(Index operandIndex = 0; operandIndex < inst.operands.getCount(); ++operandIndex) { - if(operand.flavor == SPIRVAsmOperand::SlangType) - { - // This is a $$type operand, fill in the TypeExp member of the operand - TypeExp& typeExpr = operand.type; - typeExpr.exp = operand.expr; - typeExpr = CheckProperType(typeExpr); - operand.expr = typeExpr.exp; - } - else if(operand.flavor == SPIRVAsmOperand::SlangValue - || operand.flavor == SPIRVAsmOperand::SlangValueAddr) - { - // This is a $expr operand, check the expr - operand.expr = dispatch(operand.expr); - } - else if(operand.flavor == SPIRVAsmOperand::NamedValue - && operand.token.getContent() == "result") - { - // This is the <result-id> marker, check that it only - // appears in the last instruction. + // Clamp to the end of the type info array, because the last one will be any variable operands + const auto operandType + = opInfo->operandTypes[std::min(operandIndex, Index(opInfo->numOperandTypes)-1)]; + const auto baseOperandType + = spirvInfo->operandKindUnderneathIds.lookup(operandType).value_or(operandType); + const auto needsIdWrapper = baseOperandType != operandType; - // TODO: We could consider relaxing this, because SPIR-V - // does have forward references for decorations and such - if (!isLast) + const auto check = [&](const auto& go, auto& operand) -> void { + if(operand.flavor == SPIRVAsmOperand::SlangType) { - getSink()->diagnose(operand.token, Diagnostics::misplacedResultIdMarker); - getSink()->diagnoseWithoutSourceView(expr, Diagnostics::considerOpCopyObject); + // This is a $$type operand, fill in the TypeExp member of the operand + TypeExp& typeExpr = operand.type; + typeExpr.exp = operand.expr; + typeExpr = CheckProperType(typeExpr); + operand.expr = typeExpr.exp; } - } + else if(operand.flavor == SPIRVAsmOperand::SlangValue + || operand.flavor == SPIRVAsmOperand::SlangValueAddr) + { + // This is a $expr operand, check the expr + operand.expr = dispatch(operand.expr); + } + else if(operand.flavor == SPIRVAsmOperand::ResultMarker) + { + // This is the <result-id> marker, check that it only + // appears in the last instruction. + + // TODO: We could consider relaxing this, because SPIR-V + // does have forward references for decorations and such + if (!isLast) + { + getSink()->diagnose(operand.token, Diagnostics::misplacedResultIdMarker); + getSink()->diagnoseWithoutSourceView(expr, Diagnostics::considerOpCopyObject); + } + } + else if(operand.flavor == SPIRVAsmOperand::NamedValue) + { + // First try and look it up with the knowledge of this operand's type + auto enumValue + = spirvInfo->allEnums.lookup({baseOperandType, operand.token.getContent()}); + // Then fall back to with the type prefix + if(!enumValue) + enumValue = spirvInfo->allEnumsWithTypePrefix.lookup(operand.token.getContent()); + // Then see if it's an opcode (for OpSpecialize) + if(!enumValue) + enumValue = spirvInfo->opcodes.lookup(operand.token.getContent()); + + if(!enumValue) + { + failed = true; + getSink()->diagnose(operand.token, Diagnostics::spirvUnableToResolveName, operand.token.getContent()); + return; + } + + operand.knownValue = *enumValue; + operand.wrapInId = needsIdWrapper; + } + if(operand.bitwiseOrWith.getCount() + && operand.flavor != SPIRVAsmOperand::Literal + && operand.flavor != SPIRVAsmOperand::NamedValue) + { + failed = true; + getSink()->diagnose(operand.token, Diagnostics::spirvNonConstantBitwiseOr); + } + for(auto& o : operand.bitwiseOrWith) + { + if(o.flavor != SPIRVAsmOperand::Literal && o.flavor != SPIRVAsmOperand::NamedValue) + { + failed = true; + getSink()->diagnose(operand.token, Diagnostics::spirvNonConstantBitwiseOr); + } + go(go, o); + operand.knownValue |= o.knownValue; + } + }; + + check(check, inst.operands[operandIndex]); } } + if(failed) + return CreateErrorExpr(expr); + // Assign the type of this expression from the type of the last // instruction, otherwise void if(expr->insts.getCount()) @@ -3944,8 +4014,7 @@ namespace Slang const auto lastOperands = expr->insts.getLast().operands; if(lastOperands.getCount() >= 2 && lastOperands[0].flavor == SPIRVAsmOperand::SlangType - && lastOperands[1].flavor == SPIRVAsmOperand::NamedValue - && lastOperands[1].token.getContent() == "result") + && lastOperands[1].flavor == SPIRVAsmOperand::ResultMarker) { expr->type = lastOperands[0].type.type; } diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index d87b755c7..6e4d7ff17 100755 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -14,6 +14,8 @@ #include "../compiler-core/slang-source-embed-util.h" +#include "../compiler-core/slang-spirv-core-grammar.h" + #include "../core/slang-std-writers.h" #include "../core/slang-command-options.h" @@ -2995,7 +2997,9 @@ namespace Slang *outDownstreamTime = m_downstreamCompileTime; *outTotalTime = m_totalCompileTime; } - + + SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar(char const* jsonPath) override; + /// Get the downstream compiler for a transition IDownstreamCompiler* getDownstreamCompiler(CodeGenTarget source, CodeGenTarget target); @@ -3047,6 +3051,14 @@ namespace Slang RefPtr<SharedASTBuilder> m_sharedASTBuilder; + SPIRVCoreGrammarInfo& getSPIRVCoreGrammarInfo() + { + if(!spirvCoreGrammarInfo) + setSPIRVCoreGrammar(nullptr); + SLANG_ASSERT(spirvCoreGrammarInfo); + return *spirvCoreGrammarInfo; + } + RefPtr<SPIRVCoreGrammarInfo> spirvCoreGrammarInfo; // diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h index ac6e9a932..1b13ae636 100644 --- a/source/slang/slang-diagnostic-defs.h +++ b/source/slang/slang-diagnostic-defs.h @@ -245,6 +245,13 @@ DIAGNOSTIC(29100, Error, unrecognizedSPIRVOpcode, "unrecognized spirv opcode: $0 DIAGNOSTIC(29101, Error, misplacedResultIdMarker, "the result-id marker must only be used in the last instruction of a spriv_asm expression") DIAGNOSTIC(29102, Note, considerOpCopyObject, "consider adding an OpCopyObject instruction to the end of the spirv_asm expression") DIAGNOSTIC(29103, Note, noSuchAddress, "unable to take the address of this address-of asm operand") +DIAGNOSTIC(29104, Error, spirvInstructionWithoutResultId, "cannot use this 'x = $0...' syntax because $0 does not have a <result-id> operand") +DIAGNOSTIC(29104, Error, spirvInstructionWithoutResultTypeId, "cannot use this 'x : <type> = $0...' syntax because $0 does not have a <result-type-id> operand") +// This is a warning because we trust that people using the spirv_asm block know what they're doing +DIAGNOSTIC(29104, Warning, spirvInstructionWithTooManyOperands, "too many operands for $0 (expected max $1), did you forget a semicolon?") +DIAGNOSTIC(29104, Error, spirvUnableToResolveName, "unknown SPIR-V identifier $0, it's not a known enumerator or opcode") +DIAGNOSTIC(29104, Error, spirvNonConstantBitwiseOr, "only integer literals and enum names can appear in a bitwise or expression") +DIAGNOSTIC(29104, Error, spirvOperandRange, "Literal ints must be in the range 0 to 0xffffffff") // diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp index 0022bdd85..c6aedbe3b 100644 --- a/source/slang/slang-emit-spirv.cpp +++ b/source/slang/slang-emit-spirv.cpp @@ -3808,25 +3808,34 @@ struct SPIRVEmitContext for(const auto spvInst : inst->getInsts()) { const bool isLast = spvInst == inst->getLastChild(); - const auto opcodeString = spvInst->getOpcodeString(); - SpvOp opcode; - const bool foundOpCode = lookupSpvOp(opcodeString, opcode) - || lookupSpvOp((String("Op") + opcodeString).getUnownedSlice(), opcode); - if(!foundOpCode) - { - m_sink->diagnose( - spvInst->getOpcode(), - Diagnostics::unrecognizedSPIRVOpcode, - opcodeString - ); - return nullptr; - } + const SpvOp opcode = SpvOp(spvInst->getOpcodeOperandWord()); - const auto parentForOpCode = [this](SpvOp opcode, SpvInstParent* defaultParent){ - return - opcode == SpvOpConstant ? getSection(SpvLogicalSectionID::ConstantsAndTypes) - : opcode == SpvOpName ? getSection(SpvLogicalSectionID::DebugNames) - : defaultParent; + const auto parentForOpCode = [this](SpvOp opcode, SpvInstParent* defaultParent) -> SpvInstParent*{ + const auto info = m_grammarInfo->opInfos.lookup(opcode); + SLANG_ASSERT(info.has_value()); + switch(info->class_) + { + case SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration: + case SPIRVCoreGrammarInfo::OpInfo::ConstantCreation: + return getSection(SpvLogicalSectionID::ConstantsAndTypes); + // Don't add this case, it's not correct as not all "Debug" + // instructions belong in this block + // case SPIRVCoreGrammarInfo::OpInfo::Debug: + // return getSection(SpvLogicalSectionID::DebugNames); + default: + switch(opcode) + { + case SpvOpName: + return getSection(SpvLogicalSectionID::DebugNames); + case SpvOpCapability: + return getSection(SpvLogicalSectionID::Capabilities); + case SpvOpExtension: + return getSection(SpvLogicalSectionID::Extensions); + default: + return defaultParent; + + } + } }; last = emitInstCustomOperandFunc( @@ -3843,24 +3852,48 @@ struct SPIRVEmitContext { switch(operand->getOp()) { + case kIROp_SPIRVAsmOperandEnum: case kIROp_SPIRVAsmOperandLiteral: { const auto v = as<IRConstant>(operand->getValue()); SLANG_ASSERT(v); - switch(v->getOp()) + if(operand->getOperandCount() >= 2) { - case kIROp_StringLit: - emitOperand(SpvLiteralBits::fromUnownedStringSlice(v->getStringSlice())); - break; - case kIROp_IntLit: - { - // TODO: range checking - const auto i = cast<IRIntLit>(v)->getValue(); - emitOperand(SpvLiteralInteger::from32(uint32_t(i))); - break; + const auto constantType = cast<IRType>(operand->getOperand(1)); + SpvInst* constant; + switch(v->getOp()) + { + case kIROp_IntLit: + { + // TODO: range checking + const auto i = cast<IRIntLit>(v)->getValue(); + constant = emitIntConstant(i, constantType); + break; + } + case kIROp_StringLit: + SLANG_UNIMPLEMENTED_X("String constants in SPIR-V emit"); + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + } + emitOperand(constant); } - default: - SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + else + { + switch(v->getOp()) + { + case kIROp_StringLit: + emitOperand(SpvLiteralBits::fromUnownedStringSlice(v->getStringSlice())); + break; + case kIROp_IntLit: + { + // TODO: range checking + const auto i = cast<IRIntLit>(v)->getValue(); + emitOperand(SpvLiteralInteger::from32(uint32_t(i))); + break; + } + default: + SLANG_UNREACHABLE("Unhandled case in emitSPIRVAsm"); + } } break; } @@ -3868,18 +3901,13 @@ struct SPIRVEmitContext { const auto i = operand->getValue(); emitOperand(ensureInst(i)); + break; } - case kIROp_SPIRVAsmOperandEnum: + case kIROp_SPIRVAsmOperandResult: { - const auto s = cast<IRStringLit>(operand->getValue())->getStringSlice(); - if(s == "result") - { - SLANG_ASSERT(isLast); - emitOperand(kResultID); - } - else - SLANG_UNIMPLEMENTED_X("lookup enum operands in spirv_asm"); + SLANG_ASSERT(isLast); + emitOperand(kResultID); break; } case kIROp_SPIRVAsmOperandId: diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h index 980770be5..cab7e973d 100644 --- a/source/slang/slang-ir-inst-defs.h +++ b/source/slang/slang-ir-inst-defs.h @@ -1064,14 +1064,17 @@ INST(SPIRVAsmInst, SPIRVAsmInst, 1, 0) INST(SPIRVAsmOperandLiteral, SPIRVAsmOperandLiteral, 1, 0) // A reference to a slang IRInst, either a value or a type INST(SPIRVAsmOperandInst, SPIRVAsmOperandInst, 1, 0) - // A named enumerator, the value of which is determined in the backend - // It can also have the value "result", indicating that the result-id of - // the asm block should be used + // A named enumerator, the value is stored as a constant operand + // It may have a second operand, which if present is a type with which to + // construct a constant id to pass, instead of a literal constant INST(SPIRVAsmOperandEnum, SPIRVAsmOperandEnum, 1, 0) // A string which is given a unique ID in the backend, used to refer to // results of other instrucions in the same asm block INST(SPIRVAsmOperandId, SPIRVAsmOperandId, 1, 0) -INST_RANGE(SPIRVAsmOperand, SPIRVAsmOperandLiteral, SPIRVAsmOperandId) + // A special instruction which marks the place to insert the generated + // result operand + INST(SPIRVAsmOperandResult, SPIRVAsmOperandResult, 0, 0) +INST_RANGE(SPIRVAsmOperand, SPIRVAsmOperandLiteral, SPIRVAsmOperandResult) #undef PARENT #undef USE_OTHER diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h index e12306c54..82b123bd4 100644 --- a/source/slang/slang-ir-insts.h +++ b/source/slang/slang-ir-insts.h @@ -2888,6 +2888,8 @@ struct IRSPIRVAsmOperand : IRInst IR_PARENT_ISA(SPIRVAsmOperand); IRInst* getValue() { + if(getOp() == kIROp_SPIRVAsmOperandResult) + return nullptr; return getOperand(0); } }; @@ -2896,20 +2898,20 @@ struct IRSPIRVAsmInst : IRInst { IR_LEAF_ISA(SPIRVAsmInst); - IRSPIRVAsmOperand* getOpcode() + IRSPIRVAsmOperand* getOpcodeOperand() { - // TODO: This only supports known opcodes at the moment, eventually we'll want - // another child of IRSPIRVAsm which just stores raw words const auto opcodeOperand = cast<IRSPIRVAsmOperand>(getOperand(0)); SLANG_ASSERT(opcodeOperand->getOp() == kIROp_SPIRVAsmOperandEnum); return opcodeOperand; } - UnownedStringSlice getOpcodeString() + SpvWord getOpcodeOperandWord() { - const auto opcodeOperand = getOpcode(); - const auto opcodeStringLit = cast<IRStringLit>(opcodeOperand->getValue()); - return opcodeStringLit->getStringSlice(); + const auto o = getOpcodeOperand(); + SLANG_ASSERT(o->getOp() != kIROp_SPIRVAsmOperandResult); + const auto v = o->getValue(); + const auto i = cast<IRIntLit>(v); + return SpvWord(i->getValue()); } IROperandList<IRSPIRVAsmOperand> getSPIRVOperands() @@ -3916,7 +3918,9 @@ public: IRSPIRVAsmOperand* emitSPIRVAsmOperandLiteral(IRInst* literal); IRSPIRVAsmOperand* emitSPIRVAsmOperandInst(IRInst* inst); IRSPIRVAsmOperand* emitSPIRVAsmOperandId(IRInst* inst); + IRSPIRVAsmOperand* emitSPIRVAsmOperandResult(); IRSPIRVAsmOperand* emitSPIRVAsmOperandEnum(IRInst* inst); + IRSPIRVAsmOperand* emitSPIRVAsmOperandEnum(IRInst* inst, IRType* constantType); IRSPIRVAsmInst* emitSPIRVAsmInst(IRInst* opcode, List<IRInst*> operands); IRSPIRVAsm* emitSPIRVAsm(IRType* type); diff --git a/source/slang/slang-ir-spirv-legalize.cpp b/source/slang/slang-ir-spirv-legalize.cpp index fd23d1b5e..32386e53f 100644 --- a/source/slang/slang-ir-spirv-legalize.cpp +++ b/source/slang/slang-ir-spirv-legalize.cpp @@ -854,7 +854,7 @@ SpvSnippet* SPIRVEmitSharedContext::getParsedSpvSnippet(IRTargetIntrinsicDecorat { return snippet.Ptr(); } - snippet = SpvSnippet::parse(intrinsic->getDefinition()); + snippet = SpvSnippet::parse(*m_grammarInfo, intrinsic->getDefinition()); if(!snippet) { m_sink->diagnose(intrinsic, Diagnostics::snippetParsingFailed, intrinsic->getDefinition()); diff --git a/source/slang/slang-ir-spirv-legalize.h b/source/slang/slang-ir-spirv-legalize.h index 797745f88..b11cde72f 100644 --- a/source/slang/slang-ir-spirv-legalize.h +++ b/source/slang/slang-ir-spirv-legalize.h @@ -19,8 +19,12 @@ struct SPIRVEmitSharedContext TargetRequest* m_targetRequest; Dictionary<IRTargetIntrinsicDecoration*, RefPtr<SpvSnippet>> m_parsedSpvSnippets; DiagnosticSink* m_sink; + const SPIRVCoreGrammarInfo* m_grammarInfo; SPIRVEmitSharedContext(IRModule* module, TargetRequest* target, DiagnosticSink* sink) - : m_irModule(module), m_targetRequest(target), m_sink(sink) + : m_irModule(module), + m_targetRequest(target), + m_sink(sink), + m_grammarInfo(&module->getSession()->getSPIRVCoreGrammarInfo()) {} SpvSnippet* getParsedSpvSnippet(IRTargetIntrinsicDecoration* intrinsic); }; diff --git a/source/slang/slang-ir-spirv-snippet.cpp b/source/slang/slang-ir-spirv-snippet.cpp index 98466e8ff..055eb982b 100644 --- a/source/slang/slang-ir-spirv-snippet.cpp +++ b/source/slang/slang-ir-spirv-snippet.cpp @@ -3,6 +3,7 @@ #include "slang-ir-spirv-snippet.h" #include "slang-lookup-spirv.h" #include "../core/slang-token-reader.h" +#include "../compiler-core/slang-spirv-core-grammar.h" namespace Slang { @@ -85,7 +86,9 @@ SpvWord readWordOrWordLiteral(Misc::TokenReader& reader) return ret; } -RefPtr<SpvSnippet> SpvSnippet::parse(UnownedStringSlice definition) +RefPtr<SpvSnippet> SpvSnippet::parse( + const SPIRVCoreGrammarInfo& spirvGrammar, + UnownedStringSlice definition) { RefPtr<SpvSnippet> snippet = new SpvSnippet(); try @@ -118,11 +121,13 @@ RefPtr<SpvSnippet> SpvSnippet::parse(UnownedStringSlice definition) case Slang::Misc::TokenType::Identifier: { auto opName = tokenReader.ReadWord(); - if(!lookupSpvOp(opName.getUnownedSlice(), opCode)) + const auto opCodeMaybe = spirvGrammar.opcodes.lookup(opName.getUnownedSlice()); + if(!opCodeMaybe) { throw Misc::TextFormatException( "Text parsing error: Unrecognized SPIR-V opcode: " + opName); } + opCode = *opCodeMaybe; break; } default: diff --git a/source/slang/slang-ir-spirv-snippet.h b/source/slang/slang-ir-spirv-snippet.h index 4a509a230..2b1449ea9 100644 --- a/source/slang/slang-ir-spirv-snippet.h +++ b/source/slang/slang-ir-spirv-snippet.h @@ -5,6 +5,9 @@ namespace Slang { + +struct SPIRVCoreGrammarInfo; + // // [2.2: Terms] // @@ -137,7 +140,7 @@ struct SpvSnippet : public RefObject List<ASMConstant> constants; SpvStorageClass resultStorageClass = SpvStorageClassMax; - static RefPtr<SpvSnippet> parse(UnownedStringSlice definition); + static RefPtr<SpvSnippet> parse(const SPIRVCoreGrammarInfo& spirvGrammar, UnownedStringSlice definition); }; diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp index 91a21754d..0b1e9c342 100644 --- a/source/slang/slang-ir.cpp +++ b/source/slang/slang-ir.cpp @@ -5703,6 +5703,18 @@ namespace Slang return i; } + IRSPIRVAsmOperand* IRBuilder::emitSPIRVAsmOperandResult() + { + SLANG_ASSERT(as<IRSPIRVAsm>(m_insertLoc.getParent())); + const auto i = createInst<IRSPIRVAsmOperand>( + this, + kIROp_SPIRVAsmOperandResult, + getVoidType() + ); + addInst(i); + return i; + } + IRSPIRVAsmOperand* IRBuilder::emitSPIRVAsmOperandEnum(IRInst* inst) { SLANG_ASSERT(as<IRSPIRVAsm>(m_insertLoc.getParent())); @@ -5716,6 +5728,20 @@ namespace Slang return i; } + IRSPIRVAsmOperand* IRBuilder::emitSPIRVAsmOperandEnum(IRInst* inst, IRType* constantType) + { + SLANG_ASSERT(as<IRSPIRVAsm>(m_insertLoc.getParent())); + const auto i = createInst<IRSPIRVAsmOperand>( + this, + kIROp_SPIRVAsmOperandEnum, + inst->getFullType(), + inst, + constantType + ); + addInst(i); + return i; + } + IRSPIRVAsmInst* IRBuilder::emitSPIRVAsmInst(IRInst* opcode, List<IRInst*> operands) { SLANG_ASSERT(as<IRSPIRVAsm>(m_insertLoc.getParent())); @@ -6566,6 +6592,9 @@ namespace Slang dump(context, "%"); dumpInstExpr(context, inst->getOperand(0)); return; + case kIROp_SPIRVAsmOperandResult: + dump(context, "result"); + return; } dump(context, opInfo.name); diff --git a/source/slang/slang-lookup-glslstd450.cpp b/source/slang/slang-lookup-glslstd450.cpp index cd9172cf0..2920335ec 100644 --- a/source/slang/slang-lookup-glslstd450.cpp +++ b/source/slang/slang-lookup-glslstd450.cpp @@ -12,120 +12,115 @@ namespace Slang { -static const unsigned tableSalt[81] ={ - 1, 1, 1, 1, 4, 0, 1, 0, 10, 0, 3, 0, 0, 13, 4, 1, - 5, 1, 5, 4, 0, 0, 0, 1, 0, 9, 1, 0, 0, 1, 1, 8, - 2, 0, 0, 2, 0, 1, 0, 0, 2, 1, 1, 0, 0, 0, 0, 1, - 4, 3, 9, 0, 26, 0, 0, 2, 0, 2, 8, 0, 0, 17, 20, 5, - 0, 0, 0, 5, 4, 9, 4, 23, 0, 1, 7, 0, 24, 43, 10, 41, - 6 -}; - -struct KV +bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value) { - const char* name; - GLSLstd450 value; -}; + static const unsigned tableSalt[81] = { + 1, 3, 0, 0, 6, 1, 2, 3, 0, 0, 0, 1, 4, 0, 1, 0, + 0, 0, 1, 3, 0, 0, 5, 0, 2, 0, 0, 0, 0, 0, 1, 0, + 2, 1, 1, 1, 8, 3, 1, 3, 0, 0, 3, 0, 3, 0, 9, 0, + 16, 0, 1, 0, 2, 0, 1, 1, 0, 0, 0, 2, 16, 15, 6, 1, + 1, 2, 2, 7, 7, 2, 24, 0, 16, 27, 1, 1, 176, 0, 11, 0, + 6 + }; -static const KV words[81] = -{ - {"FindSMsb", GLSLstd450FindSMsb}, - {"SClamp", GLSLstd450SClamp}, - {"UnpackHalf2x16", GLSLstd450UnpackHalf2x16}, - {"Normalize", GLSLstd450Normalize}, - {"Pow", GLSLstd450Pow}, - {"Ceil", GLSLstd450Ceil}, - {"PackUnorm4x8", GLSLstd450PackUnorm4x8}, - {"Cosh", GLSLstd450Cosh}, - {"Frexp", GLSLstd450Frexp}, - {"PackUnorm2x16", GLSLstd450PackUnorm2x16}, - {"Atan2", GLSLstd450Atan2}, - {"Exp", GLSLstd450Exp}, - {"Ldexp", GLSLstd450Ldexp}, - {"NClamp", GLSLstd450NClamp}, - {"PackHalf2x16", GLSLstd450PackHalf2x16}, - {"Trunc", GLSLstd450Trunc}, - {"UMin", GLSLstd450UMin}, - {"FClamp", GLSLstd450FClamp}, - {"SMin", GLSLstd450SMin}, - {"IMix", GLSLstd450IMix}, - {"FindUMsb", GLSLstd450FindUMsb}, - {"Cos", GLSLstd450Cos}, - {"UnpackUnorm4x8", GLSLstd450UnpackUnorm4x8}, - {"Fma", GLSLstd450Fma}, - {"RoundEven", GLSLstd450RoundEven}, - {"Log", GLSLstd450Log}, - {"Refract", GLSLstd450Refract}, - {"Distance", GLSLstd450Distance}, - {"UMax", GLSLstd450UMax}, - {"ModfStruct", GLSLstd450ModfStruct}, - {"PackSnorm4x8", GLSLstd450PackSnorm4x8}, - {"Determinant", GLSLstd450Determinant}, - {"SmoothStep", GLSLstd450SmoothStep}, - {"Reflect", GLSLstd450Reflect}, - {"Fract", GLSLstd450Fract}, - {"Asin", GLSLstd450Asin}, - {"Tanh", GLSLstd450Tanh}, - {"Degrees", GLSLstd450Degrees}, - {"Sqrt", GLSLstd450Sqrt}, - {"MatrixInverse", GLSLstd450MatrixInverse}, - {"Exp2", GLSLstd450Exp2}, - {"Cross", GLSLstd450Cross}, - {"FindILsb", GLSLstd450FindILsb}, - {"FMax", GLSLstd450FMax}, - {"NMin", GLSLstd450NMin}, - {"SMax", GLSLstd450SMax}, - {"InverseSqrt", GLSLstd450InverseSqrt}, - {"Length", GLSLstd450Length}, - {"SAbs", GLSLstd450SAbs}, - {"UClamp", GLSLstd450UClamp}, - {"FMix", GLSLstd450FMix}, - {"FaceForward", GLSLstd450FaceForward}, - {"Tan", GLSLstd450Tan}, - {"Modf", GLSLstd450Modf}, - {"PackSnorm2x16", GLSLstd450PackSnorm2x16}, - {"Round", GLSLstd450Round}, - {"UnpackUnorm2x16", GLSLstd450UnpackUnorm2x16}, - {"Atan", GLSLstd450Atan}, - {"FSign", GLSLstd450FSign}, - {"Sin", GLSLstd450Sin}, - {"UnpackSnorm2x16", GLSLstd450UnpackSnorm2x16}, - {"Radians", GLSLstd450Radians}, - {"PackDouble2x32", GLSLstd450PackDouble2x32}, - {"Sinh", GLSLstd450Sinh}, - {"UnpackSnorm4x8", GLSLstd450UnpackSnorm4x8}, - {"InterpolateAtCentroid", GLSLstd450InterpolateAtCentroid}, - {"NMax", GLSLstd450NMax}, - {"Acosh", GLSLstd450Acosh}, - {"Acos", GLSLstd450Acos}, - {"UnpackDouble2x32", GLSLstd450UnpackDouble2x32}, - {"FrexpStruct", GLSLstd450FrexpStruct}, - {"Atanh", GLSLstd450Atanh}, - {"Floor", GLSLstd450Floor}, - {"Asinh", GLSLstd450Asinh}, - {"InterpolateAtOffset", GLSLstd450InterpolateAtOffset}, - {"Step", GLSLstd450Step}, - {"FAbs", GLSLstd450FAbs}, - {"InterpolateAtSample", GLSLstd450InterpolateAtSample}, - {"Log2", GLSLstd450Log2}, - {"SSign", GLSLstd450SSign}, - {"FMin", GLSLstd450FMin}, -}; + using KV = std::pair<const char*, GLSLstd450>; -static UInt32 hash(const UnownedStringSlice& str, UInt32 salt) -{ - UInt64 h = salt; - for(const char c : str) - h = ((h * 0x00000100000001B3) ^ c); - return h % (sizeof(tableSalt)/sizeof(tableSalt[0])); -} + static const KV words[81] = + { + {"InterpolateAtOffset", GLSLstd450InterpolateAtOffset}, + {"Floor", GLSLstd450Floor}, + {"UnpackDouble2x32", GLSLstd450UnpackDouble2x32}, + {"Acosh", GLSLstd450Acosh}, + {"FindUMsb", GLSLstd450FindUMsb}, + {"Sinh", GLSLstd450Sinh}, + {"NMin", GLSLstd450NMin}, + {"Cos", GLSLstd450Cos}, + {"UMax", GLSLstd450UMax}, + {"Sqrt", GLSLstd450Sqrt}, + {"Frexp", GLSLstd450Frexp}, + {"Determinant", GLSLstd450Determinant}, + {"ModfStruct", GLSLstd450ModfStruct}, + {"PackSnorm4x8", GLSLstd450PackSnorm4x8}, + {"FrexpStruct", GLSLstd450FrexpStruct}, + {"Cross", GLSLstd450Cross}, + {"FClamp", GLSLstd450FClamp}, + {"Fract", GLSLstd450Fract}, + {"FaceForward", GLSLstd450FaceForward}, + {"MatrixInverse", GLSLstd450MatrixInverse}, + {"PackUnorm4x8", GLSLstd450PackUnorm4x8}, + {"Log2", GLSLstd450Log2}, + {"Reflect", GLSLstd450Reflect}, + {"Radians", GLSLstd450Radians}, + {"Round", GLSLstd450Round}, + {"InverseSqrt", GLSLstd450InverseSqrt}, + {"Exp", GLSLstd450Exp}, + {"Normalize", GLSLstd450Normalize}, + {"UnpackSnorm2x16", GLSLstd450UnpackSnorm2x16}, + {"InterpolateAtCentroid", GLSLstd450InterpolateAtCentroid}, + {"Refract", GLSLstd450Refract}, + {"Fma", GLSLstd450Fma}, + {"UClamp", GLSLstd450UClamp}, + {"FAbs", GLSLstd450FAbs}, + {"RoundEven", GLSLstd450RoundEven}, + {"FSign", GLSLstd450FSign}, + {"SSign", GLSLstd450SSign}, + {"Asinh", GLSLstd450Asinh}, + {"PackHalf2x16", GLSLstd450PackHalf2x16}, + {"Tan", GLSLstd450Tan}, + {"SMin", GLSLstd450SMin}, + {"Degrees", GLSLstd450Degrees}, + {"PackSnorm2x16", GLSLstd450PackSnorm2x16}, + {"FMix", GLSLstd450FMix}, + {"Atan2", GLSLstd450Atan2}, + {"PackUnorm2x16", GLSLstd450PackUnorm2x16}, + {"NMax", GLSLstd450NMax}, + {"NClamp", GLSLstd450NClamp}, + {"FindSMsb", GLSLstd450FindSMsb}, + {"Atanh", GLSLstd450Atanh}, + {"Atan", GLSLstd450Atan}, + {"Modf", GLSLstd450Modf}, + {"Cosh", GLSLstd450Cosh}, + {"Exp2", GLSLstd450Exp2}, + {"Tanh", GLSLstd450Tanh}, + {"UMin", GLSLstd450UMin}, + {"FMin", GLSLstd450FMin}, + {"Log", GLSLstd450Log}, + {"SAbs", GLSLstd450SAbs}, + {"IMix", GLSLstd450IMix}, + {"Step", GLSLstd450Step}, + {"InterpolateAtSample", GLSLstd450InterpolateAtSample}, + {"UnpackHalf2x16", GLSLstd450UnpackHalf2x16}, + {"PackDouble2x32", GLSLstd450PackDouble2x32}, + {"FMax", GLSLstd450FMax}, + {"Length", GLSLstd450Length}, + {"Distance", GLSLstd450Distance}, + {"SmoothStep", GLSLstd450SmoothStep}, + {"UnpackUnorm2x16", GLSLstd450UnpackUnorm2x16}, + {"SMax", GLSLstd450SMax}, + {"UnpackSnorm4x8", GLSLstd450UnpackSnorm4x8}, + {"Asin", GLSLstd450Asin}, + {"UnpackUnorm4x8", GLSLstd450UnpackUnorm4x8}, + {"Ldexp", GLSLstd450Ldexp}, + {"Ceil", GLSLstd450Ceil}, + {"SClamp", GLSLstd450SClamp}, + {"Trunc", GLSLstd450Trunc}, + {"Sin", GLSLstd450Sin}, + {"Pow", GLSLstd450Pow}, + {"FindILsb", GLSLstd450FindILsb}, + {"Acos", GLSLstd450Acos}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 81; + }; -bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value) -{ const auto i = hash(str, tableSalt[hash(str, 0)]); - if(str == words[i].name) + if(str == words[i].first) { - value = words[i].value; + value = words[i].second; return true; } else diff --git a/source/slang/slang-lookup-spirv.h b/source/slang/slang-lookup-spirv.h index 47cd5b277..75e75cd6d 100644 --- a/source/slang/slang-lookup-spirv.h +++ b/source/slang/slang-lookup-spirv.h @@ -5,7 +5,5 @@ namespace Slang { -bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value); bool lookupGLSLstd450(const UnownedStringSlice& str, GLSLstd450& value); -bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value); } diff --git a/source/slang/slang-lookup-spvcapability.cpp b/source/slang/slang-lookup-spvcapability.cpp deleted file mode 100644 index 5e7e18037..000000000 --- a/source/slang/slang-lookup-spvcapability.cpp +++ /dev/null @@ -1,303 +0,0 @@ -// Hash function for SpvCapability -// -// This file was thoughtfully generated by a machine, -// don't even think about modifying it yourself! -// - -#include "../core/slang-common.h" -#include "../core/slang-string.h" -#include "spirv/unified1/spirv.h" - - -namespace Slang -{ - -static const unsigned tableSalt[238] ={ - 4, 1, 0, 0, 0, 5, 1, 1, 1, 1, 0, 3, 4, 1, 0, 0, - 1, 6, 0, 1, 4, 0, 0, 1, 5, 0, 0, 1, 2, 0, 2, 2, - 0, 0, 0, 2, 3, 3, 7, 3, 0, 4, 0, 4, 5, 3, 1, 2, - 0, 6, 1, 4, 2, 1, 0, 1, 7, 3, 0, 0, 0, 1, 2, 2, - 0, 4, 1, 1, 5, 2, 0, 0, 1, 6, 4, 1, 0, 5, 1, 0, - 7, 1, 1, 2, 2, 1, 1, 0, 4, 0, 0, 2, 0, 4, 10, 0, - 0, 0, 1, 0, 4, 3, 1, 0, 0, 1, 4, 6, 2, 5, 1, 1, - 0, 3, 1, 4, 3, 1, 0, 2, 1, 0, 0, 0, 1, 1, 3, 3, - 9, 0, 0, 0, 0, 2, 5, 0, 0, 8, 0, 12, 0, 0, 0, 5, - 5, 4, 2, 1, 6, 1, 0, 0, 20, 3, 7, 1, 13, 0, 4, 14, - 5, 2, 0, 5, 0, 8, 3, 0, 1, 2, 1, 0, 3, 0, 18, 5, - 8, 0, 10, 0, 14, 0, 3, 0, 0, 0, 13, 0, 0, 2, 24, 6, - 4, 0, 3, 0, 1, 0, 0, 7, 4, 0, 0, 5, 2, 0, 35, 6, - 0, 0, 2, 5, 6, 34, 32, 29, 0, 10, 7, 0, 90, 0, 3, 36, - 73, 39, 193, 0, 1, 1, 0, 83, 8, 0, 0, 712, 2, 0 -}; - -struct KV -{ - const char* name; - SpvCapability value; -}; - -static const KV words[238] = -{ - {"ShaderViewportIndex", SpvCapabilityShaderViewportIndex}, - {"FragmentBarycentricNV", SpvCapabilityFragmentBarycentricNV}, - {"StorageImageWriteWithoutFormat", SpvCapabilityStorageImageWriteWithoutFormat}, - {"RayTracingMotionBlurNV", SpvCapabilityRayTracingMotionBlurNV}, - {"StorageImageArrayNonUniformIndexingEXT", SpvCapabilityStorageImageArrayNonUniformIndexingEXT}, - {"UnstructuredLoopControlsINTEL", SpvCapabilityUnstructuredLoopControlsINTEL}, - {"BlockingPipesINTEL", SpvCapabilityBlockingPipesINTEL}, - {"Image1D", SpvCapabilityImage1D}, - {"LiteralSampler", SpvCapabilityLiteralSampler}, - {"SubgroupAvcMotionEstimationINTEL", SpvCapabilitySubgroupAvcMotionEstimationINTEL}, - {"GroupNonUniformQuad", SpvCapabilityGroupNonUniformQuad}, - {"FunctionPointersINTEL", SpvCapabilityFunctionPointersINTEL}, - {"UniformTexelBufferArrayNonUniformIndexing", SpvCapabilityUniformTexelBufferArrayNonUniformIndexing}, - {"RayCullMaskKHR", SpvCapabilityRayCullMaskKHR}, - {"CoreBuiltinsARM", SpvCapabilityCoreBuiltinsARM}, - {"USMStorageClassesINTEL", SpvCapabilityUSMStorageClassesINTEL}, - {"ArbitraryPrecisionIntegersINTEL", SpvCapabilityArbitraryPrecisionIntegersINTEL}, - {"IOPipesINTEL", SpvCapabilityIOPipesINTEL}, - {"MultiView", SpvCapabilityMultiView}, - {"RayTracingNV", SpvCapabilityRayTracingNV}, - {"OptNoneINTEL", SpvCapabilityOptNoneINTEL}, - {"SubgroupBufferBlockIOINTEL", SpvCapabilitySubgroupBufferBlockIOINTEL}, - {"TessellationPointSize", SpvCapabilityTessellationPointSize}, - {"Vector16", SpvCapabilityVector16}, - {"RayQueryPositionFetchKHR", SpvCapabilityRayQueryPositionFetchKHR}, - {"GenericPointer", SpvCapabilityGenericPointer}, - {"UniformBufferArrayDynamicIndexing", SpvCapabilityUniformBufferArrayDynamicIndexing}, - {"ImageMSArray", SpvCapabilityImageMSArray}, - {"AtomicStorageOps", SpvCapabilityAtomicStorageOps}, - {"DotProductInputAll", SpvCapabilityDotProductInputAll}, - {"InputAttachmentArrayNonUniformIndexing", SpvCapabilityInputAttachmentArrayNonUniformIndexing}, - {"AsmINTEL", SpvCapabilityAsmINTEL}, - {"DotProductInput4x8BitPackedKHR", SpvCapabilityDotProductInput4x8BitPackedKHR}, - {"StorageTexelBufferArrayNonUniformIndexing", SpvCapabilityStorageTexelBufferArrayNonUniformIndexing}, - {"FPGADSPControlINTEL", SpvCapabilityFPGADSPControlINTEL}, - {"DotProduct", SpvCapabilityDotProduct}, - {"StorageImageMultisample", SpvCapabilityStorageImageMultisample}, - {"StorageTexelBufferArrayDynamicIndexingEXT", SpvCapabilityStorageTexelBufferArrayDynamicIndexingEXT}, - {"SampledImageArrayDynamicIndexing", SpvCapabilitySampledImageArrayDynamicIndexing}, - {"VulkanMemoryModelDeviceScopeKHR", SpvCapabilityVulkanMemoryModelDeviceScopeKHR}, - {"ShadingRateNV", SpvCapabilityShadingRateNV}, - {"DotProductInput4x8BitKHR", SpvCapabilityDotProductInput4x8BitKHR}, - {"ShaderNonUniformEXT", SpvCapabilityShaderNonUniformEXT}, - {"ShaderStereoViewNV", SpvCapabilityShaderStereoViewNV}, - {"UniformAndStorageBuffer16BitAccess", SpvCapabilityUniformAndStorageBuffer16BitAccess}, - {"RoundingModeRTE", SpvCapabilityRoundingModeRTE}, - {"TileImageColorReadAccessEXT", SpvCapabilityTileImageColorReadAccessEXT}, - {"TileImageDepthReadAccessEXT", SpvCapabilityTileImageDepthReadAccessEXT}, - {"PerViewAttributesNV", SpvCapabilityPerViewAttributesNV}, - {"DemoteToHelperInvocationEXT", SpvCapabilityDemoteToHelperInvocationEXT}, - {"AtomicFloat16MinMaxEXT", SpvCapabilityAtomicFloat16MinMaxEXT}, - {"GroupNonUniformArithmetic", SpvCapabilityGroupNonUniformArithmetic}, - {"ShaderLayer", SpvCapabilityShaderLayer}, - {"VariableLengthArrayINTEL", SpvCapabilityVariableLengthArrayINTEL}, - {"ImageReadWriteLodAMD", SpvCapabilityImageReadWriteLodAMD}, - {"ImageCubeArray", SpvCapabilityImageCubeArray}, - {"Float16Buffer", SpvCapabilityFloat16Buffer}, - {"VulkanMemoryModelDeviceScope", SpvCapabilityVulkanMemoryModelDeviceScope}, - {"ImageRect", SpvCapabilityImageRect}, - {"UniformDecoration", SpvCapabilityUniformDecoration}, - {"AtomicFloat64AddEXT", SpvCapabilityAtomicFloat64AddEXT}, - {"VectorComputeINTEL", SpvCapabilityVectorComputeINTEL}, - {"Float16", SpvCapabilityFloat16}, - {"DeviceEnqueue", SpvCapabilityDeviceEnqueue}, - {"MinLod", SpvCapabilityMinLod}, - {"Float16ImageAMD", SpvCapabilityFloat16ImageAMD}, - {"SubgroupImageMediaBlockIOINTEL", SpvCapabilitySubgroupImageMediaBlockIOINTEL}, - {"SparseResidency", SpvCapabilitySparseResidency}, - {"UniformTexelBufferArrayDynamicIndexing", SpvCapabilityUniformTexelBufferArrayDynamicIndexing}, - {"Pipes", SpvCapabilityPipes}, - {"InputAttachment", SpvCapabilityInputAttachment}, - {"FPGAMemoryAttributesINTEL", SpvCapabilityFPGAMemoryAttributesINTEL}, - {"RuntimeDescriptorArrayEXT", SpvCapabilityRuntimeDescriptorArrayEXT}, - {"GeometryPointSize", SpvCapabilityGeometryPointSize}, - {"Shader", SpvCapabilityShader}, - {"IntegerFunctions2INTEL", SpvCapabilityIntegerFunctions2INTEL}, - {"StorageImageArrayDynamicIndexing", SpvCapabilityStorageImageArrayDynamicIndexing}, - {"Int64Atomics", SpvCapabilityInt64Atomics}, - {"ImageFootprintNV", SpvCapabilityImageFootprintNV}, - {"IndirectReferencesINTEL", SpvCapabilityIndirectReferencesINTEL}, - {"ShaderSMBuiltinsNV", SpvCapabilityShaderSMBuiltinsNV}, - {"StoragePushConstant8", SpvCapabilityStoragePushConstant8}, - {"FPGAKernelAttributesINTEL", SpvCapabilityFPGAKernelAttributesINTEL}, - {"ImageBuffer", SpvCapabilityImageBuffer}, - {"ImageReadWrite", SpvCapabilityImageReadWrite}, - {"AtomicStorage", SpvCapabilityAtomicStorage}, - {"SignedZeroInfNanPreserve", SpvCapabilitySignedZeroInfNanPreserve}, - {"Groups", SpvCapabilityGroups}, - {"DebugInfoModuleINTEL", SpvCapabilityDebugInfoModuleINTEL}, - {"GroupUniformArithmeticKHR", SpvCapabilityGroupUniformArithmeticKHR}, - {"Int16", SpvCapabilityInt16}, - {"DenormFlushToZero", SpvCapabilityDenormFlushToZero}, - {"TransformFeedback", SpvCapabilityTransformFeedback}, - {"StencilExportEXT", SpvCapabilityStencilExportEXT}, - {"InputAttachmentArrayNonUniformIndexingEXT", SpvCapabilityInputAttachmentArrayNonUniformIndexingEXT}, - {"DotProductKHR", SpvCapabilityDotProductKHR}, - {"FPGABufferLocationINTEL", SpvCapabilityFPGABufferLocationINTEL}, - {"DotProductInput4x8Bit", SpvCapabilityDotProductInput4x8Bit}, - {"ShaderInvocationReorderNV", SpvCapabilityShaderInvocationReorderNV}, - {"ImageMipmap", SpvCapabilityImageMipmap}, - {"FunctionFloatControlINTEL", SpvCapabilityFunctionFloatControlINTEL}, - {"AtomicFloat16AddEXT", SpvCapabilityAtomicFloat16AddEXT}, - {"RayQueryProvisionalKHR", SpvCapabilityRayQueryProvisionalKHR}, - {"GroupNonUniformVote", SpvCapabilityGroupNonUniformVote}, - {"StorageTexelBufferArrayNonUniformIndexingEXT", SpvCapabilityStorageTexelBufferArrayNonUniformIndexingEXT}, - {"ArbitraryPrecisionFloatingPointINTEL", SpvCapabilityArbitraryPrecisionFloatingPointINTEL}, - {"StorageInputOutput16", SpvCapabilityStorageInputOutput16}, - {"SampledImageArrayNonUniformIndexing", SpvCapabilitySampledImageArrayNonUniformIndexing}, - {"SubgroupVoteKHR", SpvCapabilitySubgroupVoteKHR}, - {"Tessellation", SpvCapabilityTessellation}, - {"Geometry", SpvCapabilityGeometry}, - {"SubgroupAvcMotionEstimationChromaINTEL", SpvCapabilitySubgroupAvcMotionEstimationChromaINTEL}, - {"StorageImageReadWithoutFormat", SpvCapabilityStorageImageReadWithoutFormat}, - {"Int64", SpvCapabilityInt64}, - {"DemoteToHelperInvocation", SpvCapabilityDemoteToHelperInvocation}, - {"MeshShadingEXT", SpvCapabilityMeshShadingEXT}, - {"UniformAndStorageBuffer8BitAccess", SpvCapabilityUniformAndStorageBuffer8BitAccess}, - {"RayTracingProvisionalKHR", SpvCapabilityRayTracingProvisionalKHR}, - {"UniformBufferArrayNonUniformIndexing", SpvCapabilityUniformBufferArrayNonUniformIndexing}, - {"VulkanMemoryModelKHR", SpvCapabilityVulkanMemoryModelKHR}, - {"SubgroupShuffleINTEL", SpvCapabilitySubgroupShuffleINTEL}, - {"SubgroupDispatch", SpvCapabilitySubgroupDispatch}, - {"MemoryAccessAliasingINTEL", SpvCapabilityMemoryAccessAliasingINTEL}, - {"StorageBuffer16BitAccess", SpvCapabilityStorageBuffer16BitAccess}, - {"RuntimeDescriptorArray", SpvCapabilityRuntimeDescriptorArray}, - {"StorageImageArrayNonUniformIndexing", SpvCapabilityStorageImageArrayNonUniformIndexing}, - {"Kernel", SpvCapabilityKernel}, - {"BitInstructions", SpvCapabilityBitInstructions}, - {"WorkgroupMemoryExplicitLayout8BitAccessKHR", SpvCapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR}, - {"Sampled1D", SpvCapabilitySampled1D}, - {"StorageTexelBufferArrayDynamicIndexing", SpvCapabilityStorageTexelBufferArrayDynamicIndexing}, - {"ImageQuery", SpvCapabilityImageQuery}, - {"MultiViewport", SpvCapabilityMultiViewport}, - {"UniformTexelBufferArrayDynamicIndexingEXT", SpvCapabilityUniformTexelBufferArrayDynamicIndexingEXT}, - {"StorageUniform16", SpvCapabilityStorageUniform16}, - {"SubgroupImageBlockIOINTEL", SpvCapabilitySubgroupImageBlockIOINTEL}, - {"WorkgroupMemoryExplicitLayout16BitAccessKHR", SpvCapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR}, - {"KernelAttributesINTEL", SpvCapabilityKernelAttributesINTEL}, - {"PipeStorage", SpvCapabilityPipeStorage}, - {"ShaderViewportMaskNV", SpvCapabilityShaderViewportMaskNV}, - {"Matrix", SpvCapabilityMatrix}, - {"GroupNonUniformShuffleRelative", SpvCapabilityGroupNonUniformShuffleRelative}, - {"RuntimeAlignedAttributeINTEL", SpvCapabilityRuntimeAlignedAttributeINTEL}, - {"CullDistance", SpvCapabilityCullDistance}, - {"Int8", SpvCapabilityInt8}, - {"RayTraversalPrimitiveCullingKHR", SpvCapabilityRayTraversalPrimitiveCullingKHR}, - {"SampleMaskPostDepthCoverage", SpvCapabilitySampleMaskPostDepthCoverage}, - {"GroupNonUniformShuffle", SpvCapabilityGroupNonUniformShuffle}, - {"ImageBasic", SpvCapabilityImageBasic}, - {"WorkgroupMemoryExplicitLayoutKHR", SpvCapabilityWorkgroupMemoryExplicitLayoutKHR}, - {"FPGAClusterAttributesINTEL", SpvCapabilityFPGAClusterAttributesINTEL}, - {"PhysicalStorageBufferAddresses", SpvCapabilityPhysicalStorageBufferAddresses}, - {"UniformTexelBufferArrayNonUniformIndexingEXT", SpvCapabilityUniformTexelBufferArrayNonUniformIndexingEXT}, - {"StorageBufferArrayNonUniformIndexingEXT", SpvCapabilityStorageBufferArrayNonUniformIndexingEXT}, - {"FragmentShaderSampleInterlockEXT", SpvCapabilityFragmentShaderSampleInterlockEXT}, - {"SampledImageArrayNonUniformIndexingEXT", SpvCapabilitySampledImageArrayNonUniformIndexingEXT}, - {"InterpolationFunction", SpvCapabilityInterpolationFunction}, - {"AtomicFloat32AddEXT", SpvCapabilityAtomicFloat32AddEXT}, - {"Int64ImageEXT", SpvCapabilityInt64ImageEXT}, - {"SubgroupBallotKHR", SpvCapabilitySubgroupBallotKHR}, - {"RoundToInfinityINTEL", SpvCapabilityRoundToInfinityINTEL}, - {"DrawParameters", SpvCapabilityDrawParameters}, - {"VariablePointers", SpvCapabilityVariablePointers}, - {"FragmentShaderShadingRateInterlockEXT", SpvCapabilityFragmentShaderShadingRateInterlockEXT}, - {"NamedBarrier", SpvCapabilityNamedBarrier}, - {"ComputeDerivativeGroupQuadsNV", SpvCapabilityComputeDerivativeGroupQuadsNV}, - {"SampledCubeArray", SpvCapabilitySampledCubeArray}, - {"Addresses", SpvCapabilityAddresses}, - {"LongConstantCompositeINTEL", SpvCapabilityLongConstantCompositeINTEL}, - {"ArbitraryPrecisionFixedPointINTEL", SpvCapabilityArbitraryPrecisionFixedPointINTEL}, - {"RayTracingKHR", SpvCapabilityRayTracingKHR}, - {"RayQueryKHR", SpvCapabilityRayQueryKHR}, - {"FragmentDensityEXT", SpvCapabilityFragmentDensityEXT}, - {"InputAttachmentArrayDynamicIndexingEXT", SpvCapabilityInputAttachmentArrayDynamicIndexingEXT}, - {"FPGAInvocationPipeliningAttributesINTEL", SpvCapabilityFPGAInvocationPipeliningAttributesINTEL}, - {"ShaderViewportIndexLayerEXT", SpvCapabilityShaderViewportIndexLayerEXT}, - {"PhysicalStorageBufferAddressesEXT", SpvCapabilityPhysicalStorageBufferAddressesEXT}, - {"SplitBarrierINTEL", SpvCapabilitySplitBarrierINTEL}, - {"ImageGatherExtended", SpvCapabilityImageGatherExtended}, - {"CooperativeMatrixNV", SpvCapabilityCooperativeMatrixNV}, - {"FloatingPointModeINTEL", SpvCapabilityFloatingPointModeINTEL}, - {"SubgroupAvcMotionEstimationIntraINTEL", SpvCapabilitySubgroupAvcMotionEstimationIntraINTEL}, - {"DotProductInputAllKHR", SpvCapabilityDotProductInputAllKHR}, - {"AtomicFloat64MinMaxEXT", SpvCapabilityAtomicFloat64MinMaxEXT}, - {"DeviceGroup", SpvCapabilityDeviceGroup}, - {"RayTracingOpacityMicromapEXT", SpvCapabilityRayTracingOpacityMicromapEXT}, - {"GroupNonUniform", SpvCapabilityGroupNonUniform}, - {"BindlessTextureNV", SpvCapabilityBindlessTextureNV}, - {"GeometryShaderPassthroughNV", SpvCapabilityGeometryShaderPassthroughNV}, - {"FragmentFullyCoveredEXT", SpvCapabilityFragmentFullyCoveredEXT}, - {"ShaderNonUniform", SpvCapabilityShaderNonUniform}, - {"DotProductInput4x8BitPacked", SpvCapabilityDotProductInput4x8BitPacked}, - {"ShaderViewportIndexLayerNV", SpvCapabilityShaderViewportIndexLayerNV}, - {"RayTracingPositionFetchKHR", SpvCapabilityRayTracingPositionFetchKHR}, - {"VectorAnyINTEL", SpvCapabilityVectorAnyINTEL}, - {"FPFastMathModeINTEL", SpvCapabilityFPFastMathModeINTEL}, - {"AtomicFloat32MinMaxEXT", SpvCapabilityAtomicFloat32MinMaxEXT}, - {"SampleMaskOverrideCoverageNV", SpvCapabilitySampleMaskOverrideCoverageNV}, - {"FragmentShadingRateKHR", SpvCapabilityFragmentShadingRateKHR}, - {"GroupNonUniformPartitionedNV", SpvCapabilityGroupNonUniformPartitionedNV}, - {"StorageBufferArrayNonUniformIndexing", SpvCapabilityStorageBufferArrayNonUniformIndexing}, - {"ExpectAssumeKHR", SpvCapabilityExpectAssumeKHR}, - {"FPGAMemoryAccessesINTEL", SpvCapabilityFPGAMemoryAccessesINTEL}, - {"StorageImageExtendedFormats", SpvCapabilityStorageImageExtendedFormats}, - {"FPGAArgumentInterfacesINTEL", SpvCapabilityFPGAArgumentInterfacesINTEL}, - {"SampleRateShading", SpvCapabilitySampleRateShading}, - {"VariablePointersStorageBuffer", SpvCapabilityVariablePointersStorageBuffer}, - {"StoragePushConstant16", SpvCapabilityStoragePushConstant16}, - {"GeometryStreams", SpvCapabilityGeometryStreams}, - {"FPGARegINTEL", SpvCapabilityFPGARegINTEL}, - {"LoopFuseINTEL", SpvCapabilityLoopFuseINTEL}, - {"Linkage", SpvCapabilityLinkage}, - {"ComputeDerivativeGroupLinearNV", SpvCapabilityComputeDerivativeGroupLinearNV}, - {"DerivativeControl", SpvCapabilityDerivativeControl}, - {"StorageBufferArrayDynamicIndexing", SpvCapabilityStorageBufferArrayDynamicIndexing}, - {"SampledBuffer", SpvCapabilitySampledBuffer}, - {"StorageBuffer8BitAccess", SpvCapabilityStorageBuffer8BitAccess}, - {"FragmentBarycentricKHR", SpvCapabilityFragmentBarycentricKHR}, - {"GroupNonUniformClustered", SpvCapabilityGroupNonUniformClustered}, - {"MeshShadingNV", SpvCapabilityMeshShadingNV}, - {"RoundingModeRTZ", SpvCapabilityRoundingModeRTZ}, - {"StorageUniformBufferBlock16", SpvCapabilityStorageUniformBufferBlock16}, - {"DenormPreserve", SpvCapabilityDenormPreserve}, - {"FragmentShaderPixelInterlockEXT", SpvCapabilityFragmentShaderPixelInterlockEXT}, - {"Max", SpvCapabilityMax}, - {"GroupNonUniformBallot", SpvCapabilityGroupNonUniformBallot}, - {"InputAttachmentArrayDynamicIndexing", SpvCapabilityInputAttachmentArrayDynamicIndexing}, - {"GroupNonUniformRotateKHR", SpvCapabilityGroupNonUniformRotateKHR}, - {"ClipDistance", SpvCapabilityClipDistance}, - {"ShaderClockKHR", SpvCapabilityShaderClockKHR}, - {"FragmentMaskAMD", SpvCapabilityFragmentMaskAMD}, - {"FPGALoopControlsINTEL", SpvCapabilityFPGALoopControlsINTEL}, - {"Float64", SpvCapabilityFloat64}, - {"TileImageStencilReadAccessEXT", SpvCapabilityTileImageStencilReadAccessEXT}, - {"UniformBufferArrayNonUniformIndexingEXT", SpvCapabilityUniformBufferArrayNonUniformIndexingEXT}, - {"ImageGatherBiasLodAMD", SpvCapabilityImageGatherBiasLodAMD}, - {"SampledRect", SpvCapabilitySampledRect}, - {"VulkanMemoryModel", SpvCapabilityVulkanMemoryModel}, -}; - -static UInt32 hash(const UnownedStringSlice& str, UInt32 salt) -{ - UInt64 h = salt; - for(const char c : str) - h = ((h * 0x00000100000001B3) ^ c); - return h % (sizeof(tableSalt)/sizeof(tableSalt[0])); -} - -bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value) -{ - const auto i = hash(str, tableSalt[hash(str, 0)]); - if(str == words[i].name) - { - value = words[i].value; - return true; - } - else - { - return false; - } -} - -} diff --git a/source/slang/slang-lookup-spvop.cpp b/source/slang/slang-lookup-spvop.cpp deleted file mode 100644 index c10a25997..000000000 --- a/source/slang/slang-lookup-spvop.cpp +++ /dev/null @@ -1,813 +0,0 @@ -// Hash function for SpvOp -// -// This file was thoughtfully generated by a machine, -// don't even think about modifying it yourself! -// - -#include "../core/slang-common.h" -#include "../core/slang-string.h" -#include "spirv/unified1/spirv.h" - - -namespace Slang -{ - -static const unsigned tableSalt[718] ={ - 0, 0, 1, 5, 1, 0, 2, 0, 1, 6, 0, 1, 3, 0, 4, 1, - 1, 1, 1, 0, 0, 0, 0, 3, 2, 1, 2, 1, 1, 5, 0, 0, - 1, 1, 1, 1, 0, 0, 0, 0, 1, 9, 1, 0, 0, 1, 0, 2, - 1, 1, 0, 1, 3, 1, 3, 1, 1, 0, 0, 0, 0, 0, 2, 5, - 0, 1, 1, 0, 1, 1, 1, 1, 4, 1, 6, 2, 2, 6, 2, 1, - 1, 2, 1, 0, 1, 6, 4, 2, 0, 1, 0, 1, 1, 1, 4, 3, - 2, 4, 0, 0, 0, 2, 2, 1, 2, 0, 0, 2, 0, 5, 5, 0, - 6, 0, 0, 0, 8, 5, 2, 1, 5, 1, 0, 0, 10, 0, 0, 2, - 1, 0, 0, 2, 4, 0, 1, 2, 3, 0, 3, 0, 2, 5, 0, 2, - 0, 0, 2, 0, 2, 0, 0, 0, 1, 0, 0, 0, 6, 1, 0, 1, - 1, 2, 1, 0, 1, 1, 0, 1, 10, 2, 0, 6, 0, 0, 1, 6, - 0, 0, 9, 0, 4, 8, 0, 3, 3, 2, 0, 8, 2, 8, 0, 1, - 3, 0, 0, 0, 3, 4, 5, 6, 0, 6, 6, 2, 1, 0, 1, 1, - 5, 1, 1, 2, 2, 1, 2, 5, 1, 1, 4, 5, 1, 0, 0, 0, - 2, 0, 0, 3, 1, 4, 0, 10, 5, 1, 1, 0, 2, 4, 0, 3, - 5, 1, 1, 5, 4, 1, 7, 1, 0, 1, 0, 4, 5, 0, 0, 4, - 3, 4, 2, 0, 1, 0, 3, 4, 1, 3, 0, 0, 0, 1, 1, 0, - 0, 1, 0, 1, 0, 0, 2, 0, 3, 1, 1, 0, 0, 4, 0, 0, - 6, 0, 6, 0, 0, 2, 1, 29, 2, 0, 1, 6, 0, 0, 6, 6, - 1, 0, 0, 1, 13, 0, 2, 4, 3, 6, 1, 2, 2, 7, 0, 0, - 13, 0, 0, 2, 0, 0, 0, 0, 1, 1, 0, 2, 1, 5, 1, 0, - 2, 3, 0, 4, 5, 6, 0, 1, 2, 4, 2, 1, 1, 3, 0, 0, - 1, 1, 1, 2, 10, 0, 0, 0, 0, 0, 12, 0, 0, 6, 3, 0, - 6, 1, 6, 1, 4, 2, 1, 1, 0, 1, 0, 22, 0, 0, 15, 2, - 2, 0, 1, 10, 3, 3, 5, 1, 20, 0, 6, 3, 0, 5, 5, 0, - 0, 2, 0, 2, 0, 0, 6, 3, 1, 0, 0, 8, 0, 16, 8, 8, - 1, 1, 3, 3, 8, 5, 8, 13, 4, 0, 9, 5, 0, 0, 4, 5, - 14, 1, 0, 0, 0, 2, 0, 1, 2, 23, 0, 0, 6, 2, 2, 0, - 1, 7, 4, 0, 3, 0, 4, 1, 0, 4, 7, 0, 0, 6, 0, 4, - 0, 10, 3, 7, 18, 1, 7, 4, 2, 2, 8, 0, 0, 15, 0, 0, - 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 5, 1, 5, 0, 3, 1, - 0, 0, 3, 2, 3, 0, 0, 2, 0, 0, 3, 30, 15, 36, 1, 0, - 1, 1, 7, 19, 0, 2, 7, 8, 0, 0, 2, 49, 0, 13, 20, 7, - 10, 1, 5, 8, 4, 22, 4, 28, 0, 1, 11, 17, 1, 2, 4, 27, - 0, 0, 0, 1, 11, 8, 0, 3, 5, 3, 5, 1, 17, 1, 0, 0, - 5, 17, 0, 0, 14, 6, 0, 13, 0, 6, 21, 21, 2, 0, 0, 14, - 0, 0, 44, 5, 1, 12, 26, 6, 0, 6, 10, 0, 24, 0, 0, 7, - 5, 0, 0, 0, 0, 0, 0, 1, 2, 46, 0, 8, 0, 1, 66, 0, - 0, 15, 0, 0, 7, 0, 2, 2, 0, 0, 0, 0, 2, 0, 0, 0, - 0, 0, 0, 10, 0, 0, 0, 4, 0, 82, 4, 0, 26, 0, 0, 0, - 9, 5, 0, 0, 0, 0, 67, 0, 43, 2, 0, 0, 21, 0, 0, 0, - 2, 49, 1, 0, 0, 4, 10, 10, 11, 1, 0, 74, 5, 33, 46, 0, - 0, 169, 0, 12, 49, 3, 4, 0, 1, 38, 87, 0, 0, 16, 0, 127, - 0, 0, 0, 66, 101, 148, 0, 5, 0, 9, 0, 1, 103, 161, 122, 5, - 0, 22, 0, 0, 1, 0, 69, 0, 6, 0, 882, 0, 0, 34 -}; - -struct KV -{ - const char* name; - SpvOp value; -}; - -static const KV words[718] = -{ - {"OpImageGather", SpvOpImageGather}, - {"OpVectorInsertDynamic", SpvOpVectorInsertDynamic}, - {"OpSetUserEventStatus", SpvOpSetUserEventStatus}, - {"OpMatrixTimesScalar", SpvOpMatrixTimesScalar}, - {"OpTypePointer", SpvOpTypePointer}, - {"OpTypeBufferSurfaceINTEL", SpvOpTypeBufferSurfaceINTEL}, - {"OpSubgroupBlockReadINTEL", SpvOpSubgroupBlockReadINTEL}, - {"OpVectorTimesMatrix", SpvOpVectorTimesMatrix}, - {"OpCaptureEventProfilingInfo", SpvOpCaptureEventProfilingInfo}, - {"OpUDiv", SpvOpUDiv}, - {"OpBranch", SpvOpBranch}, - {"OpImageSampleWeightedQCOM", SpvOpImageSampleWeightedQCOM}, - {"OpAtomicFAddEXT", SpvOpAtomicFAddEXT}, - {"OpArbitraryFloatACosPiINTEL", SpvOpArbitraryFloatACosPiINTEL}, - {"OpSubgroupImageMediaBlockWriteINTEL", SpvOpSubgroupImageMediaBlockWriteINTEL}, - {"OpTypeOpaque", SpvOpTypeOpaque}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL}, - {"OpPhi", SpvOpPhi}, - {"OpRayQueryGetWorldRayDirectionKHR", SpvOpRayQueryGetWorldRayDirectionKHR}, - {"OpSizeOf", SpvOpSizeOf}, - {"OpConvertBF16ToFINTEL", SpvOpConvertBF16ToFINTEL}, - {"OpFOrdGreaterThan", SpvOpFOrdGreaterThan}, - {"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL}, - {"OpArbitraryFloatATanINTEL", SpvOpArbitraryFloatATanINTEL}, - {"OpSubgroupAvcMceSetInterShapePenaltyINTEL", SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL}, - {"OpHitObjectRecordEmptyNV", SpvOpHitObjectRecordEmptyNV}, - {"OpControlBarrier", SpvOpControlBarrier}, - {"OpFixedRecipINTEL", SpvOpFixedRecipINTEL}, - {"OpReorderThreadWithHitObjectNV", SpvOpReorderThreadWithHitObjectNV}, - {"OpTypeAvcImeResultDualReferenceStreamoutINTEL", SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL}, - {"OpSubgroupAvcSicConvertToMcePayloadINTEL", SpvOpSubgroupAvcSicConvertToMcePayloadINTEL}, - {"OpSLessThan", SpvOpSLessThan}, - {"OpFixedSqrtINTEL", SpvOpFixedSqrtINTEL}, - {"OpSatConvertSToU", SpvOpSatConvertSToU}, - {"OpReturn", SpvOpReturn}, - {"OpAssumeTrueKHR", SpvOpAssumeTrueKHR}, - {"OpTraceMotionNV", SpvOpTraceMotionNV}, - {"OpFOrdEqual", SpvOpFOrdEqual}, - {"OpSUDotAccSat", SpvOpSUDotAccSat}, - {"OpTypeMatrix", SpvOpTypeMatrix}, - {"OpTypeEvent", SpvOpTypeEvent}, - {"OpHitObjectGetGeometryIndexNV", SpvOpHitObjectGetGeometryIndexNV}, - {"OpDecorateId", SpvOpDecorateId}, - {"OpAliasScopeListDeclINTEL", SpvOpAliasScopeListDeclINTEL}, - {"OpGenericCastToPtrExplicit", SpvOpGenericCastToPtrExplicit}, - {"OpCompositeExtract", SpvOpCompositeExtract}, - {"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL}, - {"OpSelect", SpvOpSelect}, - {"OpGenericPtrMemSemantics", SpvOpGenericPtrMemSemantics}, - {"OpExtInst", SpvOpExtInst}, - {"OpLessOrGreater", SpvOpLessOrGreater}, - {"OpImageSampleDrefExplicitLod", SpvOpImageSampleDrefExplicitLod}, - {"OpTypeNamedBarrier", SpvOpTypeNamedBarrier}, - {"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL}, - {"OpImageQueryLod", SpvOpImageQueryLod}, - {"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR}, - {"OpConstantFalse", SpvOpConstantFalse}, - {"OpImageDrefGather", SpvOpImageDrefGather}, - {"OpReportIntersectionKHR", SpvOpReportIntersectionKHR}, - {"OpSUDot", SpvOpSUDot}, - {"OpConstant", SpvOpConstant}, - {"OpULessThan", SpvOpULessThan}, - {"OpConstantFunctionPointerINTEL", SpvOpConstantFunctionPointerINTEL}, - {"OpFOrdNotEqual", SpvOpFOrdNotEqual}, - {"OpConstantComposite", SpvOpConstantComposite}, - {"OpNamedBarrierInitialize", SpvOpNamedBarrierInitialize}, - {"OpSubgroupAvcMceGetInterMajorShapeINTEL", SpvOpSubgroupAvcMceGetInterMajorShapeINTEL}, - {"OpAtomicIIncrement", SpvOpAtomicIIncrement}, - {"OpImageBlockMatchSADQCOM", SpvOpImageBlockMatchSADQCOM}, - {"OpGroupNonUniformBroadcastFirst", SpvOpGroupNonUniformBroadcastFirst}, - {"OpArbitraryFloatSqrtINTEL", SpvOpArbitraryFloatSqrtINTEL}, - {"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL}, - {"OpSubgroupAvcMceConvertToImePayloadINTEL", SpvOpSubgroupAvcMceConvertToImePayloadINTEL}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL}, - {"OpFSub", SpvOpFSub}, - {"OpImageSparseFetch", SpvOpImageSparseFetch}, - {"OpSubgroupAvcMceGetInterMinorShapeINTEL", SpvOpSubgroupAvcMceGetInterMinorShapeINTEL}, - {"OpArbitraryFloatPowNINTEL", SpvOpArbitraryFloatPowNINTEL}, - {"OpGetNumPipePackets", SpvOpGetNumPipePackets}, - {"OpFwidth", SpvOpFwidth}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL}, - {"OpInBoundsPtrAccessChain", SpvOpInBoundsPtrAccessChain}, - {"OpArbitraryFloatATanPiINTEL", SpvOpArbitraryFloatATanPiINTEL}, - {"OpGroupNonUniformBallotBitCount", SpvOpGroupNonUniformBallotBitCount}, - {"OpDecorateString", SpvOpDecorateString}, - {"OpImageQueryOrder", SpvOpImageQueryOrder}, - {"OpImageSparseSampleProjImplicitLod", SpvOpImageSparseSampleProjImplicitLod}, - {"OpTypeAvcImeResultSingleReferenceStreamoutINTEL", SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL}, - {"OpCopyMemory", SpvOpCopyMemory}, - {"OpUnordered", SpvOpUnordered}, - {"OpGroupAsyncCopy", SpvOpGroupAsyncCopy}, - {"OpTraceRayKHR", SpvOpTraceRayKHR}, - {"OpBitReverse", SpvOpBitReverse}, - {"OpGroupNonUniformLogicalOr", SpvOpGroupNonUniformLogicalOr}, - {"OpIsValidEvent", SpvOpIsValidEvent}, - {"OpHitObjectGetRayTMaxNV", SpvOpHitObjectGetRayTMaxNV}, - {"OpTraceRayMotionNV", SpvOpTraceRayMotionNV}, - {"OpCapability", SpvOpCapability}, - {"OpGroupLogicalXorKHR", SpvOpGroupLogicalXorKHR}, - {"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL}, - {"OpSubgroupImageMediaBlockReadINTEL", SpvOpSubgroupImageMediaBlockReadINTEL}, - {"OpImageSparseRead", SpvOpImageSparseRead}, - {"OpSubgroupAvcImeSetWeightedSadINTEL", SpvOpSubgroupAvcImeSetWeightedSadINTEL}, - {"OpSubgroupShuffleUpINTEL", SpvOpSubgroupShuffleUpINTEL}, - {"OpExecutionMode", SpvOpExecutionMode}, - {"OpImageSparseGather", SpvOpImageSparseGather}, - {"OpSLessThanEqual", SpvOpSLessThanEqual}, - {"OpHitObjectGetShaderRecordBufferHandleNV", SpvOpHitObjectGetShaderRecordBufferHandleNV}, - {"OpImageFetch", SpvOpImageFetch}, - {"OpGroupAny", SpvOpGroupAny}, - {"OpUDotKHR", SpvOpUDotKHR}, - {"OpSubgroupAvcFmeInitializeINTEL", SpvOpSubgroupAvcFmeInitializeINTEL}, - {"OpRayQueryGenerateIntersectionKHR", SpvOpRayQueryGenerateIntersectionKHR}, - {"OpIsNormal", SpvOpIsNormal}, - {"OpSubgroupAvcImeConvertToMcePayloadINTEL", SpvOpSubgroupAvcImeConvertToMcePayloadINTEL}, - {"OpSourceContinued", SpvOpSourceContinued}, - {"OpAtomicStore", SpvOpAtomicStore}, - {"OpAtomicFlagTestAndSet", SpvOpAtomicFlagTestAndSet}, - {"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL}, - {"OpAtomicSMax", SpvOpAtomicSMax}, - {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL}, - {"OpAtomicIAdd", SpvOpAtomicIAdd}, - {"OpGroupNonUniformShuffleXor", SpvOpGroupNonUniformShuffleXor}, - {"OpConstantNull", SpvOpConstantNull}, - {"OpArbitraryFloatATan2INTEL", SpvOpArbitraryFloatATan2INTEL}, - {"OpArbitraryFloatSinPiINTEL", SpvOpArbitraryFloatSinPiINTEL}, - {"OpTypeAccelerationStructureKHR", SpvOpTypeAccelerationStructureKHR}, - {"OpTypeVmeImageINTEL", SpvOpTypeVmeImageINTEL}, - {"OpTypeStructContinuedINTEL", SpvOpTypeStructContinuedINTEL}, - {"OpLogicalNot", SpvOpLogicalNot}, - {"OpCopyMemorySized", SpvOpCopyMemorySized}, - {"OpCompositeConstruct", SpvOpCompositeConstruct}, - {"OpRayQueryGetIntersectionInstanceIdKHR", SpvOpRayQueryGetIntersectionInstanceIdKHR}, - {"OpSubgroupAvcImeRefWindowSizeINTEL", SpvOpSubgroupAvcImeRefWindowSizeINTEL}, - {"OpEndStreamPrimitive", SpvOpEndStreamPrimitive}, - {"OpBranchConditional", SpvOpBranchConditional}, - {"OpOrdered", SpvOpOrdered}, - {"OpIAverageINTEL", SpvOpIAverageINTEL}, - {"OpConvertSampledImageToUNV", SpvOpConvertSampledImageToUNV}, - {"OpIEqual", SpvOpIEqual}, - {"OpFunctionCall", SpvOpFunctionCall}, - {"OpColorAttachmentReadEXT", SpvOpColorAttachmentReadEXT}, - {"OpHitObjectGetHitKindNV", SpvOpHitObjectGetHitKindNV}, - {"OpFUnordEqual", SpvOpFUnordEqual}, - {"OpFixedCosPiINTEL", SpvOpFixedCosPiINTEL}, - {"OpSource", SpvOpSource}, - {"OpGroupNonUniformAll", SpvOpGroupNonUniformAll}, - {"OpTypeBool", SpvOpTypeBool}, - {"OpSampledImage", SpvOpSampledImage}, - {"OpAtomicLoad", SpvOpAtomicLoad}, - {"OpTypeAvcSicResultINTEL", SpvOpTypeAvcSicResultINTEL}, - {"OpSubgroupAvcImeSetDualReferenceINTEL", SpvOpSubgroupAvcImeSetDualReferenceINTEL}, - {"OpGroupFAdd", SpvOpGroupFAdd}, - {"OpSpecConstantTrue", SpvOpSpecConstantTrue}, - {"OpArbitraryFloatRecipINTEL", SpvOpArbitraryFloatRecipINTEL}, - {"OpBitwiseXor", SpvOpBitwiseXor}, - {"OpRayQueryGetIntersectionInstanceCustomIndexKHR", SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR}, - {"OpStencilAttachmentReadEXT", SpvOpStencilAttachmentReadEXT}, - {"OpFUnordLessThanEqual", SpvOpFUnordLessThanEqual}, - {"OpAsmCallINTEL", SpvOpAsmCallINTEL}, - {"OpInBoundsAccessChain", SpvOpInBoundsAccessChain}, - {"OpAbsISubINTEL", SpvOpAbsISubINTEL}, - {"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL}, - {"OpFUnordNotEqual", SpvOpFUnordNotEqual}, - {"OpSubgroupImageBlockWriteINTEL", SpvOpSubgroupImageBlockWriteINTEL}, - {"OpCommitReadPipe", SpvOpCommitReadPipe}, - {"OpSubgroupAvcSicConfigureSkcINTEL", SpvOpSubgroupAvcSicConfigureSkcINTEL}, - {"OpTypeSampledImage", SpvOpTypeSampledImage}, - {"OpCompositeInsert", SpvOpCompositeInsert}, - {"OpSubgroupAvcImeGetBorderReachedINTEL", SpvOpSubgroupAvcImeGetBorderReachedINTEL}, - {"OpGroupNonUniformRotateKHR", SpvOpGroupNonUniformRotateKHR}, - {"OpArbitraryFloatExp2INTEL", SpvOpArbitraryFloatExp2INTEL}, - {"OpGetKernelNDrangeMaxSubGroupSize", SpvOpGetKernelNDrangeMaxSubGroupSize}, - {"OpSubgroupAvcMceConvertToImeResultINTEL", SpvOpSubgroupAvcMceConvertToImeResultINTEL}, - {"OpBitwiseAnd", SpvOpBitwiseAnd}, - {"OpUMul32x16INTEL", SpvOpUMul32x16INTEL}, - {"OpConstantCompositeContinuedINTEL", SpvOpConstantCompositeContinuedINTEL}, - {"OpImageQuerySizeLod", SpvOpImageQuerySizeLod}, - {"OpArrayLength", SpvOpArrayLength}, - {"OpTypeAvcImeResultINTEL", SpvOpTypeAvcImeResultINTEL}, - {"OpTypeHitObjectNV", SpvOpTypeHitObjectNV}, - {"OpImageSampleImplicitLod", SpvOpImageSampleImplicitLod}, - {"OpMemoryNamedBarrier", SpvOpMemoryNamedBarrier}, - {"OpReportIntersectionNV", SpvOpReportIntersectionNV}, - {"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL}, - {"OpGroupNonUniformLogicalAnd", SpvOpGroupNonUniformLogicalAnd}, - {"OpArbitraryFloatGEINTEL", SpvOpArbitraryFloatGEINTEL}, - {"OpINotEqual", SpvOpINotEqual}, - {"OpUndef", SpvOpUndef}, - {"OpGroupNonUniformShuffleDown", SpvOpGroupNonUniformShuffleDown}, - {"OpSubgroupAvcMceGetBestInterDistortionsINTEL", SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL}, - {"OpSDotKHR", SpvOpSDotKHR}, - {"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL}, - {"OpArbitraryFloatMulINTEL", SpvOpArbitraryFloatMulINTEL}, - {"OpWritePipe", SpvOpWritePipe}, - {"OpGroupNonUniformSMax", SpvOpGroupNonUniformSMax}, - {"OpAtomicExchange", SpvOpAtomicExchange}, - {"OpSubgroupAvcSicGetInterRawSadsINTEL", SpvOpSubgroupAvcSicGetInterRawSadsINTEL}, - {"OpAliasDomainDeclINTEL", SpvOpAliasDomainDeclINTEL}, - {"OpRayQueryGetIntersectionObjectRayDirectionKHR", SpvOpRayQueryGetIntersectionObjectRayDirectionKHR}, - {"OpConvertImageToUNV", SpvOpConvertImageToUNV}, - {"OpGroupLogicalAndKHR", SpvOpGroupLogicalAndKHR}, - {"OpImageWrite", SpvOpImageWrite}, - {"OpArbitraryFloatAddINTEL", SpvOpArbitraryFloatAddINTEL}, - {"OpHitObjectRecordHitMotionNV", SpvOpHitObjectRecordHitMotionNV}, - {"OpImageSampleProjDrefExplicitLod", SpvOpImageSampleProjDrefExplicitLod}, - {"OpGroupSMin", SpvOpGroupSMin}, - {"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL}, - {"OpRayQueryTerminateKHR", SpvOpRayQueryTerminateKHR}, - {"OpConvertUToSamplerNV", SpvOpConvertUToSamplerNV}, - {"OpConvertFToBF16INTEL", SpvOpConvertFToBF16INTEL}, - {"OpGroupNonUniformBallotFindMSB", SpvOpGroupNonUniformBallotFindMSB}, - {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL}, - {"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL}, - {"OpShiftLeftLogical", SpvOpShiftLeftLogical}, - {"OpIsValidReserveId", SpvOpIsValidReserveId}, - {"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR}, - {"OpArbitraryFloatACosINTEL", SpvOpArbitraryFloatACosINTEL}, - {"OpGroupNonUniformBitwiseOr", SpvOpGroupNonUniformBitwiseOr}, - {"OpGroupNonUniformSMin", SpvOpGroupNonUniformSMin}, - {"OpBitFieldUExtract", SpvOpBitFieldUExtract}, - {"OpGroupNonUniformBallot", SpvOpGroupNonUniformBallot}, - {"OpSubgroupFirstInvocationKHR", SpvOpSubgroupFirstInvocationKHR}, - {"OpLoad", SpvOpLoad}, - {"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL}, - {"OpAtomicCompareExchange", SpvOpAtomicCompareExchange}, - {"OpSubgroupAvcImeGetDualReferenceStreaminINTEL", SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL}, - {"OpHitObjectRecordMissMotionNV", SpvOpHitObjectRecordMissMotionNV}, - {"OpAtomicUMin", SpvOpAtomicUMin}, - {"OpGroupCommitWritePipe", SpvOpGroupCommitWritePipe}, - {"OpFunctionParameter", SpvOpFunctionParameter}, - {"OpSubgroupShuffleXorINTEL", SpvOpSubgroupShuffleXorINTEL}, - {"OpArbitraryFloatLTINTEL", SpvOpArbitraryFloatLTINTEL}, - {"OpTranspose", SpvOpTranspose}, - {"OpSubgroupAvcSicConvertToMceResultINTEL", SpvOpSubgroupAvcSicConvertToMceResultINTEL}, - {"OpTypeCooperativeMatrixKHR", SpvOpTypeCooperativeMatrixKHR}, - {"OpTypeAvcRefResultINTEL", SpvOpTypeAvcRefResultINTEL}, - {"OpArbitraryFloatCosINTEL", SpvOpArbitraryFloatCosINTEL}, - {"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL}, - {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL}, - {"OpIgnoreIntersectionNV", SpvOpIgnoreIntersectionNV}, - {"OpArbitraryFloatCbrtINTEL", SpvOpArbitraryFloatCbrtINTEL}, - {"OpSUDotAccSatKHR", SpvOpSUDotAccSatKHR}, - {"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL}, - {"OpSubgroupAvcSicInitializeINTEL", SpvOpSubgroupAvcSicInitializeINTEL}, - {"OpISub", SpvOpISub}, - {"OpSwitch", SpvOpSwitch}, - {"OpReorderThreadWithHintNV", SpvOpReorderThreadWithHintNV}, - {"OpArbitraryFloatDivINTEL", SpvOpArbitraryFloatDivINTEL}, - {"OpArbitraryFloatEQINTEL", SpvOpArbitraryFloatEQINTEL}, - {"OpFunctionEnd", SpvOpFunctionEnd}, - {"OpSubgroupAvcSicGetMotionVectorMaskINTEL", SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL}, - {"OpKill", SpvOpKill}, - {"OpIsInf", SpvOpIsInf}, - {"OpIAdd", SpvOpIAdd}, - {"OpSubgroupAvcMceConvertToSicResultINTEL", SpvOpSubgroupAvcMceConvertToSicResultINTEL}, - {"OpIgnoreIntersectionKHR", SpvOpIgnoreIntersectionKHR}, - {"OpGetKernelMaxNumSubgroups", SpvOpGetKernelMaxNumSubgroups}, - {"OpModuleProcessed", SpvOpModuleProcessed}, - {"OpTypeArray", SpvOpTypeArray}, - {"OpUDot", SpvOpUDot}, - {"OpArbitraryFloatExp10INTEL", SpvOpArbitraryFloatExp10INTEL}, - {"OpEmitVertex", SpvOpEmitVertex}, - {"OpTypeRuntimeArray", SpvOpTypeRuntimeArray}, - {"OpImageSparseSampleDrefExplicitLod", SpvOpImageSparseSampleDrefExplicitLod}, - {"OpImageQuerySize", SpvOpImageQuerySize}, - {"OpGroupBitwiseAndKHR", SpvOpGroupBitwiseAndKHR}, - {"OpTypeAvcImeSingleReferenceStreaminINTEL", SpvOpTypeAvcImeSingleReferenceStreaminINTEL}, - {"OpHitObjectTraceRayMotionNV", SpvOpHitObjectTraceRayMotionNV}, - {"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL}, - {"OpGroupNonUniformShuffleUp", SpvOpGroupNonUniformShuffleUp}, - {"OpFConvert", SpvOpFConvert}, - {"OpImageTexelPointer", SpvOpImageTexelPointer}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL}, - {"OpGroupNonUniformBitwiseAnd", SpvOpGroupNonUniformBitwiseAnd}, - {"OpArbitraryFloatASinINTEL", SpvOpArbitraryFloatASinINTEL}, - {"OpRayQueryGetIntersectionFrontFaceKHR", SpvOpRayQueryGetIntersectionFrontFaceKHR}, - {"OpImageBlockMatchSSDQCOM", SpvOpImageBlockMatchSSDQCOM}, - {"OpGroupIAddNonUniformAMD", SpvOpGroupIAddNonUniformAMD}, - {"OpCreatePipeFromPipeStorage", SpvOpCreatePipeFromPipeStorage}, - {"OpGroupNonUniformQuadBroadcast", SpvOpGroupNonUniformQuadBroadcast}, - {"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL}, - {"OpGroupAll", SpvOpGroupAll}, - {"OpAtomicSMin", SpvOpAtomicSMin}, - {"OpAll", SpvOpAll}, - {"OpFixedRsqrtINTEL", SpvOpFixedRsqrtINTEL}, - {"OpHitObjectRecordHitNV", SpvOpHitObjectRecordHitNV}, - {"OpRayQueryGetIntersectionWorldToObjectKHR", SpvOpRayQueryGetIntersectionWorldToObjectKHR}, - {"OpSubgroupBlockWriteINTEL", SpvOpSubgroupBlockWriteINTEL}, - {"OpSubgroupAvcBmeInitializeINTEL", SpvOpSubgroupAvcBmeInitializeINTEL}, - {"OpHitObjectGetInstanceIdNV", SpvOpHitObjectGetInstanceIdNV}, - {"OpGetDefaultQueue", SpvOpGetDefaultQueue}, - {"OpCopyLogical", SpvOpCopyLogical}, - {"OpDepthAttachmentReadEXT", SpvOpDepthAttachmentReadEXT}, - {"OpSubgroupAvcSicSetBilinearFilterEnableINTEL", SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL}, - {"OpGroupWaitEvents", SpvOpGroupWaitEvents}, - {"OpIsHelperInvocationEXT", SpvOpIsHelperInvocationEXT}, - {"OpSGreaterThan", SpvOpSGreaterThan}, - {"OpHitObjectGetPrimitiveIndexNV", SpvOpHitObjectGetPrimitiveIndexNV}, - {"OpGetKernelWorkGroupSize", SpvOpGetKernelWorkGroupSize}, - {"OpArbitraryFloatExpm1INTEL", SpvOpArbitraryFloatExpm1INTEL}, - {"OpConstantSampler", SpvOpConstantSampler}, - {"OpArbitraryFloatPowRINTEL", SpvOpArbitraryFloatPowRINTEL}, - {"OpSDiv", SpvOpSDiv}, - {"OpCooperativeMatrixStoreNV", SpvOpCooperativeMatrixStoreNV}, - {"OpImageSparseTexelsResident", SpvOpImageSparseTexelsResident}, - {"OpEntryPoint", SpvOpEntryPoint}, - {"OpUConvert", SpvOpUConvert}, - {"OpArbitraryFloatSubINTEL", SpvOpArbitraryFloatSubINTEL}, - {"OpSubgroupAvcSicGetIpeChromaModeINTEL", SpvOpSubgroupAvcSicGetIpeChromaModeINTEL}, - {"OpSubgroupShuffleINTEL", SpvOpSubgroupShuffleINTEL}, - {"OpShiftRightLogical", SpvOpShiftRightLogical}, - {"OpSubgroupAvcSicConfigureIpeLumaINTEL", SpvOpSubgroupAvcSicConfigureIpeLumaINTEL}, - {"OpBitCount", SpvOpBitCount}, - {"OpTypeAvcImeDualReferenceStreaminINTEL", SpvOpTypeAvcImeDualReferenceStreaminINTEL}, - {"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL}, - {"OpImageSampleDrefImplicitLod", SpvOpImageSampleDrefImplicitLod}, - {"OpSubgroupAvcMceGetMotionVectorsINTEL", SpvOpSubgroupAvcMceGetMotionVectorsINTEL}, - {"OpArbitraryFloatLog10INTEL", SpvOpArbitraryFloatLog10INTEL}, - {"OpMatrixTimesVector", SpvOpMatrixTimesVector}, - {"OpSNegate", SpvOpSNegate}, - {"OpMemberDecorate", SpvOpMemberDecorate}, - {"OpEndPrimitive", SpvOpEndPrimitive}, - {"OpExecuteCallableKHR", SpvOpExecuteCallableKHR}, - {"OpFwidthFine", SpvOpFwidthFine}, - {"OpAbsUSubINTEL", SpvOpAbsUSubINTEL}, - {"OpGetKernelLocalSizeForSubgroupCount", SpvOpGetKernelLocalSizeForSubgroupCount}, - {"OpPtrCastToCrossWorkgroupINTEL", SpvOpPtrCastToCrossWorkgroupINTEL}, - {"OpHitObjectGetRayTMinNV", SpvOpHitObjectGetRayTMinNV}, - {"OpFOrdGreaterThanEqual", SpvOpFOrdGreaterThanEqual}, - {"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL}, - {"OpUAddSatINTEL", SpvOpUAddSatINTEL}, - {"OpAsmINTEL", SpvOpAsmINTEL}, - {"OpGroupNonUniformFMin", SpvOpGroupNonUniformFMin}, - {"OpCooperativeMatrixMulAddKHR", SpvOpCooperativeMatrixMulAddKHR}, - {"OpGroupIAdd", SpvOpGroupIAdd}, - {"OpTypeVector", SpvOpTypeVector}, - {"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL}, - {"OpArbitraryFloatCastFromIntINTEL", SpvOpArbitraryFloatCastFromIntINTEL}, - {"OpHitObjectGetObjectRayDirectionNV", SpvOpHitObjectGetObjectRayDirectionNV}, - {"OpSubgroupAvcMceGetInterDistortionsINTEL", SpvOpSubgroupAvcMceGetInterDistortionsINTEL}, - {"OpBitFieldSExtract", SpvOpBitFieldSExtract}, - {"OpSignBitSet", SpvOpSignBitSet}, - {"OpFunctionPointerCallINTEL", SpvOpFunctionPointerCallINTEL}, - {"OpConvertUToAccelerationStructureKHR", SpvOpConvertUToAccelerationStructureKHR}, - {"OpGenericCastToPtr", SpvOpGenericCastToPtr}, - {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL}, - {"OpAliasScopeDeclINTEL", SpvOpAliasScopeDeclINTEL}, - {"OpFMod", SpvOpFMod}, - {"OpUMod", SpvOpUMod}, - {"OpGroupFMulKHR", SpvOpGroupFMulKHR}, - {"OpSubgroupAvcMceGetInterDirectionsINTEL", SpvOpSubgroupAvcMceGetInterDirectionsINTEL}, - {"OpFragmentFetchAMD", SpvOpFragmentFetchAMD}, - {"OpGroupDecorate", SpvOpGroupDecorate}, - {"OpCrossWorkgroupCastToPtrINTEL", SpvOpCrossWorkgroupCastToPtrINTEL}, - {"OpConstantPipeStorage", SpvOpConstantPipeStorage}, - {"OpGroupNonUniformFMul", SpvOpGroupNonUniformFMul}, - {"OpNot", SpvOpNot}, - {"OpArbitraryFloatLEINTEL", SpvOpArbitraryFloatLEINTEL}, - {"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL}, - {"OpCooperativeMatrixLengthNV", SpvOpCooperativeMatrixLengthNV}, - {"OpTypeImage", SpvOpTypeImage}, - {"OpIAddSatINTEL", SpvOpIAddSatINTEL}, - {"OpArbitraryFloatGTINTEL", SpvOpArbitraryFloatGTINTEL}, - {"OpSMod", SpvOpSMod}, - {"OpEnqueueKernel", SpvOpEnqueueKernel}, - {"OpExtension", SpvOpExtension}, - {"OpHitObjectIsEmptyNV", SpvOpHitObjectIsEmptyNV}, - {"OpSubgroupAvcRefConvertToMceResultINTEL", SpvOpSubgroupAvcRefConvertToMceResultINTEL}, - {"OpHitObjectIsMissNV", SpvOpHitObjectIsMissNV}, - {"OpFMul", SpvOpFMul}, - {"OpStore", SpvOpStore}, - {"OpFunction", SpvOpFunction}, - {"OpSubgroupShuffleDownINTEL", SpvOpSubgroupShuffleDownINTEL}, - {"OpRayQueryGetIntersectionTriangleVertexPositionsKHR", SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR}, - {"OpFixedSinINTEL", SpvOpFixedSinINTEL}, - {"OpTypeVoid", SpvOpTypeVoid}, - {"OpFRem", SpvOpFRem}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL}, - {"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL}, - {"OpQuantizeToF16", SpvOpQuantizeToF16}, - {"OpReadClockKHR", SpvOpReadClockKHR}, - {"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL}, - {"OpImageSparseDrefGather", SpvOpImageSparseDrefGather}, - {"OpSpecConstantOp", SpvOpSpecConstantOp}, - {"OpImageSparseSampleProjExplicitLod", SpvOpImageSparseSampleProjExplicitLod}, - {"OpSubgroupAvcMceConvertToRefPayloadINTEL", SpvOpSubgroupAvcMceConvertToRefPayloadINTEL}, - {"OpEmitStreamVertex", SpvOpEmitStreamVertex}, - {"OpArbitraryFloatCosPiINTEL", SpvOpArbitraryFloatCosPiINTEL}, - {"OpArbitraryFloatExpINTEL", SpvOpArbitraryFloatExpINTEL}, - {"OpGroupBitwiseXorKHR", SpvOpGroupBitwiseXorKHR}, - {"OpArbitraryFloatSinCosINTEL", SpvOpArbitraryFloatSinCosINTEL}, - {"OpSubgroupAvcImeAdjustRefOffsetINTEL", SpvOpSubgroupAvcImeAdjustRefOffsetINTEL}, - {"OpRayQueryInitializeKHR", SpvOpRayQueryInitializeKHR}, - {"OpTerminateInvocation", SpvOpTerminateInvocation}, - {"OpFUnordLessThan", SpvOpFUnordLessThan}, - {"OpMemoryModel", SpvOpMemoryModel}, - {"OpWritePackedPrimitiveIndices4x8NV", SpvOpWritePackedPrimitiveIndices4x8NV}, - {"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL}, - {"OpMemoryBarrier", SpvOpMemoryBarrier}, - {"OpAtomicUMax", SpvOpAtomicUMax}, - {"OpVmeImageINTEL", SpvOpVmeImageINTEL}, - {"OpSubgroupAllKHR", SpvOpSubgroupAllKHR}, - {"OpOuterProduct", SpvOpOuterProduct}, - {"OpArbitraryFloatSinINTEL", SpvOpArbitraryFloatSinINTEL}, - {"OpSpecConstant", SpvOpSpecConstant}, - {"OpGroupUMinNonUniformAMD", SpvOpGroupUMinNonUniformAMD}, - {"OpArbitraryFloatHypotINTEL", SpvOpArbitraryFloatHypotINTEL}, - {"OpVectorTimesScalar", SpvOpVectorTimesScalar}, - {"OpHitObjectGetObjectRayOriginNV", SpvOpHitObjectGetObjectRayOriginNV}, - {"OpLogicalEqual", SpvOpLogicalEqual}, - {"OpSubgroupReadInvocationKHR", SpvOpSubgroupReadInvocationKHR}, - {"OpLabel", SpvOpLabel}, - {"OpImageSparseSampleExplicitLod", SpvOpImageSparseSampleExplicitLod}, - {"OpBuildNDRange", SpvOpBuildNDRange}, - {"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL}, - {"OpGroupNonUniformBroadcast", SpvOpGroupNonUniformBroadcast}, - {"OpCooperativeMatrixLoadKHR", SpvOpCooperativeMatrixLoadKHR}, - {"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL}, - {"OpGroupNonUniformInverseBallot", SpvOpGroupNonUniformInverseBallot}, - {"OpImageQueryFormat", SpvOpImageQueryFormat}, - {"OpRayQueryProceedKHR", SpvOpRayQueryProceedKHR}, - {"OpAtomicIDecrement", SpvOpAtomicIDecrement}, - {"OpCooperativeMatrixLengthKHR", SpvOpCooperativeMatrixLengthKHR}, - {"OpHitObjectGetWorldRayDirectionNV", SpvOpHitObjectGetWorldRayDirectionNV}, - {"OpGroupFMin", SpvOpGroupFMin}, - {"OpAtomicFMaxEXT", SpvOpAtomicFMaxEXT}, - {"OpImageSampleFootprintNV", SpvOpImageSampleFootprintNV}, - {"OpConvertUToPtr", SpvOpConvertUToPtr}, - {"OpGroupNonUniformPartitionNV", SpvOpGroupNonUniformPartitionNV}, - {"OpPtrCastToGeneric", SpvOpPtrCastToGeneric}, - {"OpAtomicFMinEXT", SpvOpAtomicFMinEXT}, - {"OpLifetimeStart", SpvOpLifetimeStart}, - {"OpHitObjectRecordMissNV", SpvOpHitObjectRecordMissNV}, - {"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL}, - {"OpReadPipe", SpvOpReadPipe}, - {"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL}, - {"OpImageSampleProjDrefImplicitLod", SpvOpImageSampleProjDrefImplicitLod}, - {"OpAny", SpvOpAny}, - {"OpIMul32x16INTEL", SpvOpIMul32x16INTEL}, - {"OpImageRead", SpvOpImageRead}, - {"OpEndInvocationInterlockEXT", SpvOpEndInvocationInterlockEXT}, - {"OpUSubSatINTEL", SpvOpUSubSatINTEL}, - {"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL}, - {"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL}, - {"OpPtrEqual", SpvOpPtrEqual}, - {"OpArbitraryFloatLog2INTEL", SpvOpArbitraryFloatLog2INTEL}, - {"OpSConvert", SpvOpSConvert}, - {"OpSubgroupAvcImeInitializeINTEL", SpvOpSubgroupAvcImeInitializeINTEL}, - {"OpDPdx", SpvOpDPdx}, - {"OpGroupNonUniformUMin", SpvOpGroupNonUniformUMin}, - {"OpUnreachable", SpvOpUnreachable}, - {"OpTypePipeStorage", SpvOpTypePipeStorage}, - {"OpRayQueryConfirmIntersectionKHR", SpvOpRayQueryConfirmIntersectionKHR}, - {"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL}, - {"OpGroupUMin", SpvOpGroupUMin}, - {"OpGroupFMax", SpvOpGroupFMax}, - {"OpLogicalAnd", SpvOpLogicalAnd}, - {"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL}, - {"OpFixedCosINTEL", SpvOpFixedCosINTEL}, - {"OpFUnordGreaterThanEqual", SpvOpFUnordGreaterThanEqual}, - {"OpMemberDecorateString", SpvOpMemberDecorateString}, - {"OpGroupNonUniformIAdd", SpvOpGroupNonUniformIAdd}, - {"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL}, - {"OpLoopMerge", SpvOpLoopMerge}, - {"OpSubgroupAvcMceConvertToSicPayloadINTEL", SpvOpSubgroupAvcMceConvertToSicPayloadINTEL}, - {"OpTypeAvcImePayloadINTEL", SpvOpTypeAvcImePayloadINTEL}, - {"OpImageSampleExplicitLod", SpvOpImageSampleExplicitLod}, - {"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL}, - {"OpReservedWritePipe", SpvOpReservedWritePipe}, - {"OpGroupMemberDecorate", SpvOpGroupMemberDecorate}, - {"OpPtrAccessChain", SpvOpPtrAccessChain}, - {"OpConvertUToF", SpvOpConvertUToF}, - {"OpRayQueryGetIntersectionTKHR", SpvOpRayQueryGetIntersectionTKHR}, - {"OpCooperativeMatrixMulAddNV", SpvOpCooperativeMatrixMulAddNV}, - {"OpTypeAvcMcePayloadINTEL", SpvOpTypeAvcMcePayloadINTEL}, - {"OpCooperativeMatrixLoadNV", SpvOpCooperativeMatrixLoadNV}, - {"OpExecutionModeId", SpvOpExecutionModeId}, - {"OpSRem", SpvOpSRem}, - {"OpImageQueryLevels", SpvOpImageQueryLevels}, - {"OpSubgroupAvcRefConvertToMcePayloadINTEL", SpvOpSubgroupAvcRefConvertToMcePayloadINTEL}, - {"OpGroupReserveWritePipePackets", SpvOpGroupReserveWritePipePackets}, - {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL}, - {"OpSMulExtended", SpvOpSMulExtended}, - {"OpISubSatINTEL", SpvOpISubSatINTEL}, - {"OpDPdyFine", SpvOpDPdyFine}, - {"OpGroupSMinNonUniformAMD", SpvOpGroupSMinNonUniformAMD}, - {"OpGroupNonUniformBallotFindLSB", SpvOpGroupNonUniformBallotFindLSB}, - {"OpImageQuerySamples", SpvOpImageQuerySamples}, - {"OpGroupBroadcast", SpvOpGroupBroadcast}, - {"OpImage", SpvOpImage}, - {"OpTypePipe", SpvOpTypePipe}, - {"OpFixedSinCosINTEL", SpvOpFixedSinCosINTEL}, - {"OpRayQueryGetIntersectionObjectToWorldKHR", SpvOpRayQueryGetIntersectionObjectToWorldKHR}, - {"OpRayQueryGetIntersectionBarycentricsKHR", SpvOpRayQueryGetIntersectionBarycentricsKHR}, - {"OpLogicalOr", SpvOpLogicalOr}, - {"OpNop", SpvOpNop}, - {"OpImageSparseSampleProjDrefExplicitLod", SpvOpImageSparseSampleProjDrefExplicitLod}, - {"OpTypeReserveId", SpvOpTypeReserveId}, - {"OpImageSparseSampleImplicitLod", SpvOpImageSparseSampleImplicitLod}, - {"OpImageSparseSampleProjDrefImplicitLod", SpvOpImageSparseSampleProjDrefImplicitLod}, - {"OpImageSampleProjImplicitLod", SpvOpImageSampleProjImplicitLod}, - {"OpLifetimeStop", SpvOpLifetimeStop}, - {"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL}, - {"OpGetKernelNDrangeSubGroupCount", SpvOpGetKernelNDrangeSubGroupCount}, - {"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL}, - {"OpGroupNonUniformAllEqual", SpvOpGroupNonUniformAllEqual}, - {"OpSGreaterThanEqual", SpvOpSGreaterThanEqual}, - {"OpRayQueryGetIntersectionTypeKHR", SpvOpRayQueryGetIntersectionTypeKHR}, - {"OpDPdxFine", SpvOpDPdxFine}, - {"OpIsFinite", SpvOpIsFinite}, - {"OpName", SpvOpName}, - {"OpHitObjectGetObjectToWorldNV", SpvOpHitObjectGetObjectToWorldNV}, - {"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL}, - {"OpEmitMeshTasksEXT", SpvOpEmitMeshTasksEXT}, - {"OpGroupSMaxNonUniformAMD", SpvOpGroupSMaxNonUniformAMD}, - {"OpUGreaterThanEqual", SpvOpUGreaterThanEqual}, - {"OpUCountLeadingZerosINTEL", SpvOpUCountLeadingZerosINTEL}, - {"OpAccessChain", SpvOpAccessChain}, - {"OpCommitWritePipe", SpvOpCommitWritePipe}, - {"OpFPGARegINTEL", SpvOpFPGARegINTEL}, - {"OpUDotAccSat", SpvOpUDotAccSat}, - {"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL}, - {"OpGroupNonUniformFAdd", SpvOpGroupNonUniformFAdd}, - {"OpGroupNonUniformAny", SpvOpGroupNonUniformAny}, - {"OpHitObjectRecordHitWithIndexNV", SpvOpHitObjectRecordHitWithIndexNV}, - {"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL}, - {"OpGroupNonUniformShuffle", SpvOpGroupNonUniformShuffle}, - {"OpExtInstImport", SpvOpExtInstImport}, - {"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL}, - {"OpGetMaxPipePackets", SpvOpGetMaxPipePackets}, - {"OpSubgroupAvcMceGetInterReferenceIdsINTEL", SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL}, - {"OpTypeAvcSicPayloadINTEL", SpvOpTypeAvcSicPayloadINTEL}, - {"OpAtomicAnd", SpvOpAtomicAnd}, - {"OpGroupUMax", SpvOpGroupUMax}, - {"OpEnqueueMarker", SpvOpEnqueueMarker}, - {"OpRestoreMemoryINTEL", SpvOpRestoreMemoryINTEL}, - {"OpRayQueryGetIntersectionObjectRayOriginKHR", SpvOpRayQueryGetIntersectionObjectRayOriginKHR}, - {"OpFAdd", SpvOpFAdd}, - {"OpDecorationGroup", SpvOpDecorationGroup}, - {"OpSUDotKHR", SpvOpSUDotKHR}, - {"OpGroupUMaxNonUniformAMD", SpvOpGroupUMaxNonUniformAMD}, - {"OpReleaseEvent", SpvOpReleaseEvent}, - {"OpArbitraryFloatLogINTEL", SpvOpArbitraryFloatLogINTEL}, - {"OpUDotAccSatKHR", SpvOpUDotAccSatKHR}, - {"OpBitFieldInsert", SpvOpBitFieldInsert}, - {"OpConvertSamplerToUNV", SpvOpConvertSamplerToUNV}, - {"OpHitObjectRecordHitWithIndexMotionNV", SpvOpHitObjectRecordHitWithIndexMotionNV}, - {"OpGroupNonUniformElect", SpvOpGroupNonUniformElect}, - {"OpRayQueryGetRayFlagsKHR", SpvOpRayQueryGetRayFlagsKHR}, - {"OpAtomicXor", SpvOpAtomicXor}, - {"OpBitwiseOr", SpvOpBitwiseOr}, - {"OpSatConvertUToS", SpvOpSatConvertUToS}, - {"OpArbitraryFloatCastToIntINTEL", SpvOpArbitraryFloatCastToIntINTEL}, - {"OpTypeQueue", SpvOpTypeQueue}, - {"OpDecorateStringGOOGLE", SpvOpDecorateStringGOOGLE}, - {"OpISubBorrow", SpvOpISubBorrow}, - {"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL}, - {"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL}, - {"OpGroupNonUniformBallotBitExtract", SpvOpGroupNonUniformBallotBitExtract}, - {"OpFOrdLessThan", SpvOpFOrdLessThan}, - {"OpFixedLogINTEL", SpvOpFixedLogINTEL}, - {"OpVectorShuffle", SpvOpVectorShuffle}, - {"OpArbitraryFloatRSqrtINTEL", SpvOpArbitraryFloatRSqrtINTEL}, - {"OpHitObjectGetShaderBindingTableRecordIndexNV", SpvOpHitObjectGetShaderBindingTableRecordIndexNV}, - {"OpTypeFunction", SpvOpTypeFunction}, - {"OpReservedReadPipe", SpvOpReservedReadPipe}, - {"OpImageSparseSampleDrefImplicitLod", SpvOpImageSparseSampleDrefImplicitLod}, - {"OpDemoteToHelperInvocation", SpvOpDemoteToHelperInvocation}, - {"OpSpecConstantComposite", SpvOpSpecConstantComposite}, - {"OpFOrdLessThanEqual", SpvOpFOrdLessThanEqual}, - {"OpGroupBitwiseOrKHR", SpvOpGroupBitwiseOrKHR}, - {"OpMemberName", SpvOpMemberName}, - {"OpGroupNonUniformBitwiseXor", SpvOpGroupNonUniformBitwiseXor}, - {"OpGroupFAddNonUniformAMD", SpvOpGroupFAddNonUniformAMD}, - {"OpMatrixTimesMatrix", SpvOpMatrixTimesMatrix}, - {"OpSubgroupAvcRefSetBilinearFilterEnableINTEL", SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL}, - {"OpTypeSampler", SpvOpTypeSampler}, - {"OpGroupLogicalOrKHR", SpvOpGroupLogicalOrKHR}, - {"OpHitObjectGetWorldToObjectNV", SpvOpHitObjectGetWorldToObjectNV}, - {"OpMemberDecorateStringGOOGLE", SpvOpMemberDecorateStringGOOGLE}, - {"OpTypeInt", SpvOpTypeInt}, - {"OpSDotAccSatKHR", SpvOpSDotAccSatKHR}, - {"OpUMulExtended", SpvOpUMulExtended}, - {"OpRayQueryGetIntersectionGeometryIndexKHR", SpvOpRayQueryGetIntersectionGeometryIndexKHR}, - {"OpGroupReserveReadPipePackets", SpvOpGroupReserveReadPipePackets}, - {"OpDemoteToHelperInvocationEXT", SpvOpDemoteToHelperInvocationEXT}, - {"OpTerminateRayKHR", SpvOpTerminateRayKHR}, - {"OpCreateUserEvent", SpvOpCreateUserEvent}, - {"OpFDiv", SpvOpFDiv}, - {"OpSubgroupAvcMceGetInterMotionVectorCountINTEL", SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL}, - {"OpSDot", SpvOpSDot}, - {"OpArbitraryFloatCastINTEL", SpvOpArbitraryFloatCastINTEL}, - {"OpImageBoxFilterQCOM", SpvOpImageBoxFilterQCOM}, - {"OpSubgroupBallotKHR", SpvOpSubgroupBallotKHR}, - {"OpSelectionMerge", SpvOpSelectionMerge}, - {"OpConvertUToSampledImageNV", SpvOpConvertUToSampledImageNV}, - {"OpConvertFToU", SpvOpConvertFToU}, - {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL}, - {"OpRetainEvent", SpvOpRetainEvent}, - {"OpULessThanEqual", SpvOpULessThanEqual}, - {"OpUAverageINTEL", SpvOpUAverageINTEL}, - {"OpSDotAccSat", SpvOpSDotAccSat}, - {"OpShiftRightArithmetic", SpvOpShiftRightArithmetic}, - {"OpArbitraryFloatPowINTEL", SpvOpArbitraryFloatPowINTEL}, - {"OpSubgroupAvcMceSetAcOnlyHaarINTEL", SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL}, - {"OpTraceNV", SpvOpTraceNV}, - {"OpArbitraryFloatSinCosPiINTEL", SpvOpArbitraryFloatSinCosPiINTEL}, - {"OpSubgroupAvcSicGetIpeLumaShapeINTEL", SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL}, - {"OpReadPipeBlockingINTEL", SpvOpReadPipeBlockingINTEL}, - {"OpVariableLengthArrayINTEL", SpvOpVariableLengthArrayINTEL}, - {"OpArbitraryFloatASinPiINTEL", SpvOpArbitraryFloatASinPiINTEL}, - {"OpSubgroupImageBlockReadINTEL", SpvOpSubgroupImageBlockReadINTEL}, - {"OpVectorExtractDynamic", SpvOpVectorExtractDynamic}, - {"OpReserveReadPipePackets", SpvOpReserveReadPipePackets}, - {"OpReserveWritePipePackets", SpvOpReserveWritePipePackets}, - {"OpGroupNonUniformUMax", SpvOpGroupNonUniformUMax}, - {"OpBeginInvocationInterlockEXT", SpvOpBeginInvocationInterlockEXT}, - {"OpLoopControlINTEL", SpvOpLoopControlINTEL}, - {"OpFixedSinCosPiINTEL", SpvOpFixedSinCosPiINTEL}, - {"OpReturnValue", SpvOpReturnValue}, - {"OpHitObjectGetAttributesNV", SpvOpHitObjectGetAttributesNV}, - {"OpExpectKHR", SpvOpExpectKHR}, - {"OpIsNan", SpvOpIsNan}, - {"OpGroupIMulKHR", SpvOpGroupIMulKHR}, - {"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL}, - {"OpPtrNotEqual", SpvOpPtrNotEqual}, - {"OpSpecConstantFalse", SpvOpSpecConstantFalse}, - {"OpFixedExpINTEL", SpvOpFixedExpINTEL}, - {"OpTerminateRayNV", SpvOpTerminateRayNV}, - {"OpUCountTrailingZerosINTEL", SpvOpUCountTrailingZerosINTEL}, - {"OpAsmTargetINTEL", SpvOpAsmTargetINTEL}, - {"OpSaveMemoryINTEL", SpvOpSaveMemoryINTEL}, - {"OpRayQueryGetRayTMinKHR", SpvOpRayQueryGetRayTMinKHR}, - {"OpTypeRayQueryKHR", SpvOpTypeRayQueryKHR}, - {"OpSpecConstantCompositeContinuedINTEL", SpvOpSpecConstantCompositeContinuedINTEL}, - {"OpConvertSToF", SpvOpConvertSToF}, - {"OpCooperativeMatrixStoreKHR", SpvOpCooperativeMatrixStoreKHR}, - {"OpRayQueryGetIntersectionPrimitiveIndexKHR", SpvOpRayQueryGetIntersectionPrimitiveIndexKHR}, - {"OpHitObjectGetCurrentTimeNV", SpvOpHitObjectGetCurrentTimeNV}, - {"OpRayQueryGetWorldRayOriginKHR", SpvOpRayQueryGetWorldRayOriginKHR}, - {"OpHitObjectGetInstanceCustomIndexNV", SpvOpHitObjectGetInstanceCustomIndexNV}, - {"OpSubgroupAnyKHR", SpvOpSubgroupAnyKHR}, - {"OpTypeFloat", SpvOpTypeFloat}, - {"OpIAddCarry", SpvOpIAddCarry}, - {"OpSubgroupAvcImeSetSingleReferenceINTEL", SpvOpSubgroupAvcImeSetSingleReferenceINTEL}, - {"OpAtomicISub", SpvOpAtomicISub}, - {"OpAtomicOr", SpvOpAtomicOr}, - {"OpGroupCommitReadPipe", SpvOpGroupCommitReadPipe}, - {"OpSetMeshOutputsEXT", SpvOpSetMeshOutputsEXT}, - {"OpDPdy", SpvOpDPdy}, - {"OpDPdxCoarse", SpvOpDPdxCoarse}, - {"OpLogicalNotEqual", SpvOpLogicalNotEqual}, - {"OpTypeStruct", SpvOpTypeStruct}, - {"OpIAverageRoundedINTEL", SpvOpIAverageRoundedINTEL}, - {"OpHitObjectExecuteShaderNV", SpvOpHitObjectExecuteShaderNV}, - {"OpTypeCooperativeMatrixNV", SpvOpTypeCooperativeMatrixNV}, - {"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL}, - {"OpTypeDeviceEvent", SpvOpTypeDeviceEvent}, - {"OpSubgroupAvcImeConvertToMceResultINTEL", SpvOpSubgroupAvcImeConvertToMceResultINTEL}, - {"OpFragmentMaskFetchAMD", SpvOpFragmentMaskFetchAMD}, - {"OpSamplerImageAddressingModeNV", SpvOpSamplerImageAddressingModeNV}, - {"OpConvertUToImageNV", SpvOpConvertUToImageNV}, - {"OpConvertFToS", SpvOpConvertFToS}, - {"OpFUnordGreaterThan", SpvOpFUnordGreaterThan}, - {"OpSourceExtension", SpvOpSourceExtension}, - {"OpGroupSMax", SpvOpGroupSMax}, - {"OpFixedSinPiINTEL", SpvOpFixedSinPiINTEL}, - {"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL}, - {"OpGroupNonUniformIMul", SpvOpGroupNonUniformIMul}, - {"OpNoLine", SpvOpNoLine}, - {"OpDPdyCoarse", SpvOpDPdyCoarse}, - {"OpControlBarrierArriveINTEL", SpvOpControlBarrierArriveINTEL}, - {"OpFNegate", SpvOpFNegate}, - {"OpTypeAvcRefPayloadINTEL", SpvOpTypeAvcRefPayloadINTEL}, - {"OpCopyObject", SpvOpCopyObject}, - {"OpTypeAvcMceResultINTEL", SpvOpTypeAvcMceResultINTEL}, - {"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL}, - {"OpSubgroupAvcMceConvertToRefResultINTEL", SpvOpSubgroupAvcMceConvertToRefResultINTEL}, - {"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL}, - {"OpExecuteCallableNV", SpvOpExecuteCallableNV}, - {"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL}, - {"OpControlBarrierWaitINTEL", SpvOpControlBarrierWaitINTEL}, - {"OpHitObjectTraceRayNV", SpvOpHitObjectTraceRayNV}, - {"OpDot", SpvOpDot}, - {"OpUGreaterThan", SpvOpUGreaterThan}, - {"OpArbitraryFloatLog1pINTEL", SpvOpArbitraryFloatLog1pINTEL}, - {"OpVariable", SpvOpVariable}, - {"OpDecorate", SpvOpDecorate}, - {"OpFwidthCoarse", SpvOpFwidthCoarse}, - {"OpGroupNonUniformFMax", SpvOpGroupNonUniformFMax}, - {"OpTypeForwardPointer", SpvOpTypeForwardPointer}, - {"OpBitcast", SpvOpBitcast}, - {"OpPtrDiff", SpvOpPtrDiff}, - {"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL}, - {"OpAtomicFlagClear", SpvOpAtomicFlagClear}, - {"OpTypeAccelerationStructureNV", SpvOpTypeAccelerationStructureNV}, - {"OpLine", SpvOpLine}, - {"OpWritePipeBlockingINTEL", SpvOpWritePipeBlockingINTEL}, - {"OpGroupNonUniformQuadSwap", SpvOpGroupNonUniformQuadSwap}, - {"OpGroupNonUniformLogicalXor", SpvOpGroupNonUniformLogicalXor}, - {"OpGroupFMinNonUniformAMD", SpvOpGroupFMinNonUniformAMD}, - {"OpString", SpvOpString}, - {"OpImageSampleProjExplicitLod", SpvOpImageSampleProjExplicitLod}, - {"OpHitObjectIsHitNV", SpvOpHitObjectIsHitNV}, - {"OpSubgroupAllEqualKHR", SpvOpSubgroupAllEqualKHR}, - {"OpUAverageRoundedINTEL", SpvOpUAverageRoundedINTEL}, - {"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL}, - {"OpAtomicCompareExchangeWeak", SpvOpAtomicCompareExchangeWeak}, - {"OpSubgroupAvcSicEvaluateIpeINTEL", SpvOpSubgroupAvcSicEvaluateIpeINTEL}, - {"OpConvertPtrToU", SpvOpConvertPtrToU}, - {"OpConstantTrue", SpvOpConstantTrue}, - {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL}, - {"OpHitObjectGetWorldRayOriginNV", SpvOpHitObjectGetWorldRayOriginNV}, - {"OpIMul", SpvOpIMul}, - {"OpGroupFMaxNonUniformAMD", SpvOpGroupFMaxNonUniformAMD}, - {"OpGetKernelPreferredWorkGroupSizeMultiple", SpvOpGetKernelPreferredWorkGroupSizeMultiple}, -}; - -static UInt32 hash(const UnownedStringSlice& str, UInt32 salt) -{ - UInt64 h = salt; - for(const char c : str) - h = ((h * 0x00000100000001B3) ^ c); - return h % (sizeof(tableSalt)/sizeof(tableSalt[0])); -} - -bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value) -{ - const auto i = hash(str, tableSalt[hash(str, 0)]); - if(str == words[i].name) - { - value = words[i].value; - return true; - } - else - { - return false; - } -} - -} diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index 854485185..1b97414fb 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -3263,11 +3263,10 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> { if(operand.token.type == TokenType::IntegerLiteral) { - const auto v = getIntegerLiteralValue(operand.token); // TODO: we should sign-extend these where appropriate, // difficult because it requires information on usage... return builder->emitSPIRVAsmOperandLiteral( - builder->getIntValue(builder->getUIntType(), v)); + builder->getIntValue(builder->getUIntType(), operand.knownValue)); } else if(operand.token.type == TokenType::StringLiteral) { @@ -3283,11 +3282,18 @@ struct ExprLoweringVisitorBase : ExprVisitor<Derived, LoweredValInfo> return builder->emitSPIRVAsmOperandId( builder->getStringValue(id)); } + case SPIRVAsmOperand::ResultMarker: + { + return builder->emitSPIRVAsmOperandResult(); + } case SPIRVAsmOperand::NamedValue: { - const auto id = operand.token.getContent(); - return builder->emitSPIRVAsmOperandEnum( - builder->getStringValue(id)); + const auto v = operand.knownValue; + const auto i = builder->getIntValue(builder->getIntType(), v); + if(operand.wrapInId) + return builder->emitSPIRVAsmOperandEnum(i, builder->getIntType()); + else + return builder->emitSPIRVAsmOperandEnum(i); } case SPIRVAsmOperand::SlangValue: { diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index 5d3f7e015..545f222de 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.cpp @@ -102,6 +102,7 @@ enum class OptionKind EmitSpirvViaGLSL, EmitSpirvDirectly, + SPIRVCoreGrammarJSON, // Downstream @@ -518,6 +519,8 @@ void initCommandOptions(CommandOptions& options) "Generate SPIR-V output by compiling generated GLSL with glslang (default)" }, { OptionKind::EmitSpirvDirectly, "-emit-spirv-directly", nullptr, "Generate SPIR-V output direclty rather than by compiling generated GLSL with glslang" }, + { OptionKind::SPIRVCoreGrammarJSON, "-spirv-core-grammar", nullptr, + "A path to a specific spirv.core.grammar.json to use when generating SPIR-V output" }, #endif }; @@ -889,6 +892,8 @@ struct OptionsParser slang::CompileStdLibFlags m_compileStdLibFlags = 0; bool m_hasLoadedRepro = false; + String m_spirvCoreGrammarJSONPath; + CommandLineReader m_reader; CommandOptionsWriter::Style m_helpStyle = CommandOptionsWriter::Style::Text; @@ -2300,6 +2305,13 @@ SlangResult OptionsParser::_parse( getCurrentTarget()->targetFlags |= SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY; } break; + case OptionKind::SPIRVCoreGrammarJSON: + { + CommandLineArg path; + SLANG_RETURN_ON_FAIL(m_reader.expectArg(path)); + m_spirvCoreGrammarJSONPath = path.value; + } + break; case OptionKind::DefaultDownstreamCompiler: { @@ -2843,6 +2855,11 @@ SlangResult OptionsParser::_parse( m_compileRequest->setMatrixLayoutMode(m_defaultMatrixLayoutMode); } + if(m_spirvCoreGrammarJSONPath.getLength()) + { + m_session->setSPIRVCoreGrammar(m_spirvCoreGrammarJSONPath.getBuffer()); + } + // Next we need to sort out the output files specified with `-o`, and // figure out which entry point and/or target they apply to. // diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index 442ddbce6..580215fc7 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -6160,14 +6160,27 @@ namespace Slang return SPIRVAsmOperand{flavor, tok, varExpr}; }; + // The result marker + if(parser->LookAheadToken("result")) + { + return SPIRVAsmOperand{SPIRVAsmOperand::ResultMarker, parser->ReadToken()}; + } // A regular identifier - if(parser->LookAheadToken(TokenType::Identifier)) + else if(parser->LookAheadToken(TokenType::Identifier)) { return SPIRVAsmOperand{SPIRVAsmOperand::NamedValue, parser->ReadToken()}; } - // A literal integer or string - else if(parser->LookAheadToken(TokenType::IntegerLiteral) - || parser->LookAheadToken(TokenType::StringLiteral)) + // A literal integer + else if(parser->LookAheadToken(TokenType::IntegerLiteral)) + { + const auto tok = parser->ReadToken(); + const auto v = getIntegerLiteralValue(tok); + if(v < 0 || v > 0xffffffff) + parser->diagnose(tok, Diagnostics::spirvOperandRange); + return SPIRVAsmOperand{SPIRVAsmOperand::Literal, tok, nullptr, {}, SpvWord(v)}; + } + // A literal string + else if(parser->LookAheadToken(TokenType::StringLiteral)) { return SPIRVAsmOperand{SPIRVAsmOperand::Literal, parser->ReadToken()}; } @@ -6202,37 +6215,120 @@ namespace Slang static std::optional<SPIRVAsmInst> parseSPIRVAsmInst(Parser* parser) { + const auto& spirvInfo = parser->astBuilder->getGlobalSession()->spirvCoreGrammarInfo; + SPIRVAsmInst ret; + // We don't yet know if this is "OpFoo a b c" or "a = OpFoo b c" const auto resultOrOpcode = parseSPIRVAsmOperand(parser); if(!resultOrOpcode) return std::nullopt; - // We can enable this when we have a way of determining the index of - // the result id operand to each instruction, otherwise we don't know - // at which position in the operand list to insert this. -#if 0 - if(AdvanceIf(parser, TokenType::OpEql)) + // If this is the latter, "assignment", syntax then we'll fill these in + std::optional<SPIRVAsmOperand> resultTypeOperand; + std::optional<SPIRVAsmOperand> resultOperand; + + // If we see a colon, then this `%foo : %type = OpFoo`? + if(AdvanceIf(parser, TokenType::Colon)) + { + resultTypeOperand = parseSPIRVAsmOperand(parser); + if(!resultTypeOperand) + return std::nullopt; + parser->ReadToken(TokenType::OpAssign); + } + + // If we have seen a type, then insist on this syntax, otherwise allow + // skipping this if + if(resultTypeOperand || AdvanceIf(parser, TokenType::OpAssign)) { const auto opcode = parseSPIRVAsmOperand(parser); if(!opcode) return std::nullopt; ret.opcode = *opcode; - ret.operands.insert(???, *resultOrOpcode); + resultOperand = *resultOrOpcode; } else -#endif { ret.opcode = *resultOrOpcode; } - // TODO: diagnose wrong opcode flavor here + const auto& opcodeWord = spirvInfo->opcodes.lookup(ret.opcode.token.getContent()); + const auto& opInfo = opcodeWord + ? spirvInfo->opInfos.lookup(*opcodeWord) + : std::nullopt; + ret.opcode.knownValue = opcodeWord.value_or(SpvOp(0xffffffff)); + + // If we couldn't find any info, but used this assignment syntax, raise + // an error + if(!opInfo && resultOperand) + { + parser->diagnose( + resultOperand->token, + Diagnostics::unrecognizedSPIRVOpcode, + ret.opcode.token + ); + return std::nullopt; + } + + // If we have an explicit result operand (because this was a `x = + // OpFoo` instruction) then diagnose if we don't know where to put it + if(resultOperand && opInfo && opInfo->resultIdIndex == -1) + { + parser->diagnose( + resultOperand->token, + Diagnostics::spirvInstructionWithoutResultId, + ret.opcode.token + ); + return std::nullopt; + } + + // Likewise for the type + if(resultTypeOperand && opInfo && opInfo->resultTypeIndex == -1) + { + parser->diagnose( + resultTypeOperand->token, + Diagnostics::spirvInstructionWithoutResultTypeId, + ret.opcode.token + ); + return std::nullopt; + } + // + // Now we've parsed the tricky preamble, grab the rest of the operands + // At this point we can also parse bitwise or expressions + // while(!(parser->LookAheadToken(TokenType::RBrace) || parser->LookAheadToken(TokenType::Semicolon))) { - if(const auto operand = parseSPIRVAsmOperand(parser)) + if(ret.operands.getCount() == opInfo->maxOperandCount) + { + parser->diagnose( + parser->tokenReader.peekLoc(), + Diagnostics::spirvInstructionWithTooManyOperands, + ret.opcode.token, + opInfo->maxOperandCount + ); + } + + // Insert the LHS result-type operand + if(ret.operands.getCount() == opInfo->resultTypeIndex && resultTypeOperand) + ret.operands.add(*resultTypeOperand); + + // Insert the LHS result operand + if(ret.operands.getCount() == opInfo->resultIdIndex && resultOperand) + ret.operands.add(*resultOperand); + + if(auto operand = parseSPIRVAsmOperand(parser)) + { + while(AdvanceIf(parser, TokenType::OpBitOr)) + { + if(const auto next = parseSPIRVAsmOperand(parser)) + operand->bitwiseOrWith.add(*next); + else + return std::nullopt; + } ret.operands.add(*operand); + } else return std::nullopt; } @@ -6245,6 +6341,7 @@ namespace Slang SPIRVAsmExpr* asmExpr = parser->astBuilder->create<SPIRVAsmExpr>(); parser->ReadToken(TokenType::LBrace); + bool failed = false; while(!parser->tokenReader.isAtEnd()) { if(parser->LookAheadToken(TokenType::RBrace)) @@ -6252,14 +6349,21 @@ namespace Slang if(const auto inst = parseSPIRVAsmInst(parser)) asmExpr->insts.add(*inst); else - return nullptr; + { + failed = true; + // Recover to the semi or brace + while(!(parser->LookAheadToken(TokenType::Semicolon) + || parser->LookAheadToken(TokenType::RBrace) + || parser->LookAheadToken(TokenType::EndOfFile))) + parser->ReadToken(); + } if(parser->LookAheadToken(TokenType::RBrace)) break; parser->ReadToken(TokenType::Semicolon); } - parser->ReadToken(TokenType::RBrace); + parser->ReadMatchingToken(TokenType::RBrace); - return asmExpr; + return failed ? nullptr : asmExpr; } static Expr* parsePrefixExpr(Parser* parser) @@ -6655,10 +6759,15 @@ namespace Slang Token token; token = parser->ReadToken(); auto modifier = parser->astBuilder->create<RequiredSPIRVCapabilityModifier>(); - SpvCapability cap; - if (!lookupSpvCapability(token.getContent(), cap)) + const SPIRVCoreGrammarInfo& spirvInfo = + parser->astBuilder->getGlobalSession()->getSPIRVCoreGrammarInfo(); + const auto cap = spirvInfo.capabilities.lookup(token.getContent()); + if (!cap) + { parser->sink->diagnose(token, Diagnostics::unknownSPIRVCapability, token); - modifier->capability = (int32_t)cap; + return nullptr; + } + modifier->capability = int32_t(*cap); return modifier; } diff --git a/source/slang/slang-spirv-core-grammar-embed.cpp b/source/slang/slang-spirv-core-grammar-embed.cpp new file mode 100644 index 000000000..ee409dad0 --- /dev/null +++ b/source/slang/slang-spirv-core-grammar-embed.cpp @@ -0,0 +1,12451 @@ +// Source embedding for SPIR-V core grammar +// +// This file was carefully generated by a machine, +// don't even think about modifying it yourself! +// + +#include "../core/slang-smart-pointer.h" +#include "../compiler-core/slang-spirv-core-grammar.h" +namespace Slang +{ +using OperandKind = SPIRVCoreGrammarInfo::OperandKind; +using QualifiedEnumName = SPIRVCoreGrammarInfo::QualifiedEnumName; +using QualifiedEnumValue = SPIRVCoreGrammarInfo::QualifiedEnumValue; +static bool lookupSpvOp(const UnownedStringSlice& str, SpvOp& value) +{ + static const unsigned tableSalt[718] = { + 0, 8, 0, 1, 0, 2, 0, 0, 1, 0, 1, 0, 0, 0, 2, 1, + 1, 0, 0, 4, 1, 2, 1, 0, 3, 3, 0, 1, 1, 0, 4, 10, + 4, 2, 0, 0, 2, 0, 2, 9, 1, 3, 0, 5, 0, 0, 0, 0, + 2, 0, 3, 0, 0, 1, 3, 0, 5, 1, 0, 1, 0, 5, 1, 0, + 1, 0, 4, 2, 0, 2, 0, 3, 0, 2, 2, 2, 0, 0, 0, 0, + 5, 0, 0, 8, 2, 8, 1, 2, 0, 2, 0, 6, 0, 3, 0, 2, + 0, 1, 0, 0, 7, 0, 0, 0, 1, 4, 1, 0, 1, 1, 1, 0, + 1, 2, 2, 1, 0, 4, 3, 1, 0, 0, 3, 3, 1, 1, 1, 3, + 1, 1, 0, 1, 1, 1, 0, 2, 0, 2, 0, 0, 2, 3, 4, 5, + 4, 0, 1, 0, 5, 0, 0, 7, 10, 7, 0, 1, 3, 1, 1, 1, + 0, 0, 0, 1, 3, 0, 0, 4, 0, 0, 5, 7, 0, 5, 0, 0, + 1, 1, 0, 0, 0, 1, 5, 11, 2, 2, 0, 1, 1, 2, 0, 0, + 5, 3, 3, 1, 2, 2, 1, 4, 2, 0, 2, 7, 6, 0, 3, 0, + 3, 3, 0, 4, 3, 3, 6, 1, 6, 0, 0, 0, 6, 2, 1, 1, + 6, 0, 2, 0, 2, 2, 4, 2, 11, 0, 2, 0, 6, 2, 0, 15, + 5, 4, 0, 7, 10, 1, 5, 1, 3, 0, 0, 1, 0, 5, 1, 2, + 5, 3, 0, 12, 1, 0, 1, 0, 1, 1, 0, 1, 4, 2, 4, 4, + 1, 0, 0, 0, 0, 1, 1, 0, 1, 7, 0, 0, 1, 2, 11, 0, + 8, 1, 7, 1, 4, 5, 3, 5, 2, 9, 0, 4, 0, 7, 0, 4, + 4, 1, 1, 1, 0, 4, 1, 8, 0, 0, 0, 0, 3, 5, 0, 0, + 1, 0, 1, 7, 4, 5, 8, 4, 0, 0, 0, 0, 2, 1, 0, 5, + 0, 2, 2, 8, 5, 0, 0, 7, 0, 1, 12, 0, 0, 1, 0, 4, + 0, 5, 0, 0, 0, 11, 0, 1, 0, 1, 1, 0, 0, 0, 4, 5, + 0, 0, 25, 9, 3, 9, 0, 24, 0, 1, 2, 2, 0, 2, 0, 0, + 21, 4, 0, 0, 1, 4, 0, 3, 0, 1, 1, 1, 13, 0, 0, 0, + 0, 0, 0, 1, 4, 1, 0, 0, 5, 8, 0, 0, 1, 0, 6, 4, + 0, 1, 0, 0, 0, 1, 6, 3, 6, 9, 5, 0, 3, 5, 12, 4, + 0, 34, 7, 1, 2, 2, 3, 0, 1, 13, 3, 0, 3, 5, 1, 1, + 1, 7, 0, 0, 0, 0, 6, 6, 6, 0, 0, 5, 0, 0, 9, 0, + 0, 5, 0, 0, 2, 9, 0, 0, 0, 27, 0, 32, 8, 0, 5, 9, + 7, 0, 0, 28, 0, 0, 13, 1, 7, 0, 3, 0, 0, 2, 4, 0, + 31, 0, 0, 2, 0, 1, 14, 0, 7, 3, 0, 0, 2, 10, 1, 1, + 4, 0, 18, 0, 2, 0, 0, 0, 22, 0, 18, 13, 0, 0, 1, 0, + 0, 6, 21, 17, 7, 0, 17, 5, 0, 70, 0, 0, 1, 27, 3, 14, + 0, 0, 39, 9, 3, 2, 11, 17, 0, 2, 0, 21, 5, 1, 0, 3, + 0, 2, 10, 5, 0, 2, 11, 0, 0, 2, 0, 15, 6, 0, 0, 1, + 0, 5, 12, 11, 0, 8, 9, 2, 4, 0, 7, 0, 12, 0, 5, 21, + 3, 0, 1, 0, 8, 0, 0, 1, 13, 0, 7, 12, 0, 0, 6, 1, + 2, 0, 0, 36, 6, 0, 21, 0, 0, 3, 0, 3, 2, 0, 12, 0, + 0, 25, 11, 1, 2, 0, 10, 0, 0, 0, 0, 3, 0, 40, 0, 2, + 58, 2, 17, 39, 13, 2, 1, 0, 7, 0, 5, 22, 42, 36, 23, 0, + 0, 50, 19, 0, 5, 0, 15, 3, 17, 0, 0, 9, 32, 23, 21, 0, + 4, 1, 1, 0, 2, 11, 0, 0, 0, 14, 9, 0, 0, 35, 0, 75, + 0, 4, 26, 0, 0, 232, 15, 83, 8, 401, 14, 2, 0, 0, 1, 0, + 0, 16, 43, 7, 0, 3, 11, 246, 112, 40, 44, 676, 104, 4 + }; + + using KV = std::pair<const char*, SpvOp>; + + static const KV words[718] = + { + {"OpIsValidEvent", static_cast<SpvOp>(300)}, + {"OpTypeBufferSurfaceINTEL", static_cast<SpvOp>(6086)}, + {"OpReservedWritePipe", static_cast<SpvOp>(277)}, + {"OpFUnordGreaterThan", static_cast<SpvOp>(187)}, + {"OpMemoryBarrier", static_cast<SpvOp>(225)}, + {"OpTraceRayKHR", static_cast<SpvOp>(4445)}, + {"OpIsFinite", static_cast<SpvOp>(158)}, + {"OpReorderThreadWithHitObjectNV", static_cast<SpvOp>(5279)}, + {"OpLifetimeStop", static_cast<SpvOp>(257)}, + {"OpImage", static_cast<SpvOp>(100)}, + {"OpSubgroupAvcImeConvertToMcePayloadINTEL", static_cast<SpvOp>(5752)}, + {"OpImageQuerySizeLod", static_cast<SpvOp>(103)}, + {"OpNamedBarrierInitialize", static_cast<SpvOp>(328)}, + {"OpRayQueryGenerateIntersectionKHR", static_cast<SpvOp>(4475)}, + {"OpGroupUMax", static_cast<SpvOp>(270)}, + {"OpHitObjectRecordMissNV", static_cast<SpvOp>(5263)}, + {"OpFOrdEqual", static_cast<SpvOp>(180)}, + {"OpSUDot", static_cast<SpvOp>(4452)}, + {"OpConvertSamplerToUNV", static_cast<SpvOp>(5394)}, + {"OpImageSparseSampleProjImplicitLod", static_cast<SpvOp>(309)}, + {"OpGroupNonUniformLogicalOr", static_cast<SpvOp>(363)}, + {"OpArbitraryFloatSinCosINTEL", static_cast<SpvOp>(5870)}, + {"OpImageFetch", static_cast<SpvOp>(95)}, + {"OpSpecConstantCompositeContinuedINTEL", static_cast<SpvOp>(6092)}, + {"OpSubgroupAvcImeRefWindowSizeINTEL", static_cast<SpvOp>(5750)}, + {"OpGroupNonUniformBroadcastFirst", static_cast<SpvOp>(338)}, + {"OpImageSampleProjImplicitLod", static_cast<SpvOp>(91)}, + {"OpBitCount", static_cast<SpvOp>(205)}, + {"OpSubgroupAvcMceGetInterMotionVectorCountINTEL", static_cast<SpvOp>(5744)}, + {"OpAsmCallINTEL", static_cast<SpvOp>(5611)}, + {"OpImageSparseSampleProjExplicitLod", static_cast<SpvOp>(310)}, + {"OpFUnordNotEqual", static_cast<SpvOp>(183)}, + {"OpGroupBitwiseAndKHR", static_cast<SpvOp>(6403)}, + {"OpSpecConstantComposite", static_cast<SpvOp>(51)}, + {"OpTypeCooperativeMatrixKHR", static_cast<SpvOp>(4456)}, + {"OpGroupNonUniformRotateKHR", static_cast<SpvOp>(4431)}, + {"OpFixedSqrtINTEL", static_cast<SpvOp>(5923)}, + {"OpTerminateInvocation", static_cast<SpvOp>(4416)}, + {"OpBitwiseOr", static_cast<SpvOp>(197)}, + {"OpDecorationGroup", static_cast<SpvOp>(73)}, + {"OpSpecConstantFalse", static_cast<SpvOp>(49)}, + {"OpAccessChain", static_cast<SpvOp>(65)}, + {"OpLoopMerge", static_cast<SpvOp>(246)}, + {"OpImageSampleWeightedQCOM", static_cast<SpvOp>(4480)}, + {"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", static_cast<SpvOp>(5714)}, + {"OpSDotAccSat", static_cast<SpvOp>(4453)}, + {"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", static_cast<SpvOp>(5755)}, + {"OpSubgroupAvcMceGetBestInterDistortionsINTEL", static_cast<SpvOp>(5740)}, + {"OpMemberDecorateStringGOOGLE", static_cast<SpvOp>(5633)}, + {"OpUAverageINTEL", static_cast<SpvOp>(5592)}, + {"OpVectorTimesMatrix", static_cast<SpvOp>(144)}, + {"OpShiftRightLogical", static_cast<SpvOp>(194)}, + {"OpAssumeTrueKHR", static_cast<SpvOp>(5630)}, + {"OpGroupCommitWritePipe", static_cast<SpvOp>(288)}, + {"OpGroupAsyncCopy", static_cast<SpvOp>(259)}, + {"OpHitObjectTraceRayNV", static_cast<SpvOp>(5260)}, + {"OpAliasDomainDeclINTEL", static_cast<SpvOp>(5911)}, + {"OpUSubSatINTEL", static_cast<SpvOp>(5596)}, + {"OpHitObjectGetWorldToObjectNV", static_cast<SpvOp>(5252)}, + {"OpArbitraryFloatSinCosPiINTEL", static_cast<SpvOp>(5840)}, + {"OpArbitraryFloatPowRINTEL", static_cast<SpvOp>(5881)}, + {"OpSubgroupAvcMceGetMotionVectorsINTEL", static_cast<SpvOp>(5738)}, + {"OpFwidth", static_cast<SpvOp>(209)}, + {"OpLogicalNot", static_cast<SpvOp>(168)}, + {"OpGenericPtrMemSemantics", static_cast<SpvOp>(69)}, + {"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", static_cast<SpvOp>(5715)}, + {"OpImageSparseSampleExplicitLod", static_cast<SpvOp>(306)}, + {"OpArbitraryFloatExpINTEL", static_cast<SpvOp>(5864)}, + {"OpPhi", static_cast<SpvOp>(245)}, + {"OpUConvert", static_cast<SpvOp>(113)}, + {"OpConstantCompositeContinuedINTEL", static_cast<SpvOp>(6091)}, + {"OpUDotKHR", static_cast<SpvOp>(4451)}, + {"OpGetDefaultQueue", static_cast<SpvOp>(303)}, + {"OpFOrdGreaterThan", static_cast<SpvOp>(186)}, + {"OpSUDotAccSat", static_cast<SpvOp>(4455)}, + {"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", static_cast<SpvOp>(5719)}, + {"OpTypeAvcMceResultINTEL", static_cast<SpvOp>(5705)}, + {"OpImageQueryLod", static_cast<SpvOp>(105)}, + {"OpControlBarrierWaitINTEL", static_cast<SpvOp>(6143)}, + {"OpMemberDecorateString", static_cast<SpvOp>(5633)}, + {"OpFUnordEqual", static_cast<SpvOp>(181)}, + {"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", static_cast<SpvOp>(6021)}, + {"OpTypeAvcImeResultINTEL", static_cast<SpvOp>(5706)}, + {"OpSDiv", static_cast<SpvOp>(135)}, + {"OpSubgroupAvcMceGetInterDirectionsINTEL", static_cast<SpvOp>(5743)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", static_cast<SpvOp>(5764)}, + {"OpDecorateStringGOOGLE", static_cast<SpvOp>(5632)}, + {"OpEndStreamPrimitive", static_cast<SpvOp>(221)}, + {"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", static_cast<SpvOp>(5724)}, + {"OpHitObjectRecordMissMotionNV", static_cast<SpvOp>(5251)}, + {"OpConvertUToSamplerNV", static_cast<SpvOp>(5392)}, + {"OpGroupNonUniformSMin", static_cast<SpvOp>(353)}, + {"OpTypePipeStorage", static_cast<SpvOp>(322)}, + {"OpDecorate", static_cast<SpvOp>(71)}, + {"OpArbitraryFloatDivINTEL", static_cast<SpvOp>(5849)}, + {"OpCooperativeMatrixLoadKHR", static_cast<SpvOp>(4457)}, + {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", static_cast<SpvOp>(5772)}, + {"OpImageQueryOrder", static_cast<SpvOp>(102)}, + {"OpArbitraryFloatExp2INTEL", static_cast<SpvOp>(5865)}, + {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", static_cast<SpvOp>(5774)}, + {"OpINotEqual", static_cast<SpvOp>(171)}, + {"OpGroupFMin", static_cast<SpvOp>(266)}, + {"OpDot", static_cast<SpvOp>(148)}, + {"OpArbitraryFloatLEINTEL", static_cast<SpvOp>(5853)}, + {"OpGroupNonUniformFMin", static_cast<SpvOp>(355)}, + {"OpFixedCosINTEL", static_cast<SpvOp>(5927)}, + {"OpDPdx", static_cast<SpvOp>(207)}, + {"OpDPdy", static_cast<SpvOp>(208)}, + {"OpVectorShuffle", static_cast<SpvOp>(79)}, + {"OpSubgroupBlockWriteINTEL", static_cast<SpvOp>(5576)}, + {"OpFunction", static_cast<SpvOp>(54)}, + {"OpCommitWritePipe", static_cast<SpvOp>(281)}, + {"OpImageBlockMatchSADQCOM", static_cast<SpvOp>(4483)}, + {"OpImageQuerySize", static_cast<SpvOp>(104)}, + {"OpImageTexelPointer", static_cast<SpvOp>(60)}, + {"OpBranchConditional", static_cast<SpvOp>(250)}, + {"OpEmitVertex", static_cast<SpvOp>(218)}, + {"OpAtomicFlagTestAndSet", static_cast<SpvOp>(318)}, + {"OpTypeAccelerationStructureNV", static_cast<SpvOp>(5341)}, + {"OpGenericCastToPtr", static_cast<SpvOp>(122)}, + {"OpSubgroupAvcRefConvertToMcePayloadINTEL", static_cast<SpvOp>(5783)}, + {"OpBitReverse", static_cast<SpvOp>(204)}, + {"OpSLessThan", static_cast<SpvOp>(177)}, + {"OpGroupNonUniformElect", static_cast<SpvOp>(333)}, + {"OpHitObjectGetGeometryIndexNV", static_cast<SpvOp>(5269)}, + {"OpGroupNonUniformFMax", static_cast<SpvOp>(358)}, + {"OpTypeEvent", static_cast<SpvOp>(34)}, + {"OpSubgroupAvcSicConfigureSkcINTEL", static_cast<SpvOp>(5792)}, + {"OpMatrixTimesScalar", static_cast<SpvOp>(143)}, + {"OpISub", static_cast<SpvOp>(130)}, + {"OpAtomicUMin", static_cast<SpvOp>(237)}, + {"OpBitFieldSExtract", static_cast<SpvOp>(202)}, + {"OpGroupFMulKHR", static_cast<SpvOp>(6402)}, + {"OpGroupIAdd", static_cast<SpvOp>(264)}, + {"OpAtomicStore", static_cast<SpvOp>(228)}, + {"OpIMul", static_cast<SpvOp>(132)}, + {"OpDPdyCoarse", static_cast<SpvOp>(214)}, + {"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", static_cast<SpvOp>(5787)}, + {"OpGroupNonUniformBitwiseOr", static_cast<SpvOp>(360)}, + {"OpEmitMeshTasksEXT", static_cast<SpvOp>(5294)}, + {"OpConvertUToImageNV", static_cast<SpvOp>(5391)}, + {"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", static_cast<SpvOp>(5725)}, + {"OpQuantizeToF16", static_cast<SpvOp>(116)}, + {"OpSUDotKHR", static_cast<SpvOp>(4452)}, + {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", static_cast<SpvOp>(5775)}, + {"OpSubgroupFirstInvocationKHR", static_cast<SpvOp>(4422)}, + {"OpSGreaterThanEqual", static_cast<SpvOp>(175)}, + {"OpString", static_cast<SpvOp>(7)}, + {"OpUDiv", static_cast<SpvOp>(134)}, + {"OpGetKernelNDrangeMaxSubGroupSize", static_cast<SpvOp>(294)}, + {"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", static_cast<SpvOp>(5746)}, + {"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", static_cast<SpvOp>(5784)}, + {"OpRayQueryTerminateKHR", static_cast<SpvOp>(4474)}, + {"OpSConvert", static_cast<SpvOp>(114)}, + {"OpArbitraryFloatATanINTEL", static_cast<SpvOp>(5877)}, + {"OpReturnValue", static_cast<SpvOp>(254)}, + {"OpSLessThanEqual", static_cast<SpvOp>(179)}, + {"OpSNegate", static_cast<SpvOp>(126)}, + {"OpTypeStruct", static_cast<SpvOp>(30)}, + {"OpPtrDiff", static_cast<SpvOp>(403)}, + {"OpFixedCosPiINTEL", static_cast<SpvOp>(5930)}, + {"OpReportIntersectionKHR", static_cast<SpvOp>(5334)}, + {"OpCopyLogical", static_cast<SpvOp>(400)}, + {"OpLogicalOr", static_cast<SpvOp>(166)}, + {"OpSubgroupAvcRefSetBilinearFilterEnableINTEL", static_cast<SpvOp>(5785)}, + {"OpEntryPoint", static_cast<SpvOp>(15)}, + {"OpRayQueryGetIntersectionFrontFaceKHR", static_cast<SpvOp>(6025)}, + {"OpHitObjectGetObjectRayOriginNV", static_cast<SpvOp>(5255)}, + {"OpLessOrGreater", static_cast<SpvOp>(161)}, + {"OpBuildNDRange", static_cast<SpvOp>(304)}, + {"OpSMulExtended", static_cast<SpvOp>(152)}, + {"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", static_cast<SpvOp>(5794)}, + {"OpReserveReadPipePackets", static_cast<SpvOp>(278)}, + {"OpExtInst", static_cast<SpvOp>(12)}, + {"OpArbitraryFloatPowINTEL", static_cast<SpvOp>(5880)}, + {"OpSubgroupReadInvocationKHR", static_cast<SpvOp>(4432)}, + {"OpGroupFAddNonUniformAMD", static_cast<SpvOp>(5001)}, + {"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", static_cast<SpvOp>(5726)}, + {"OpHitObjectGetHitKindNV", static_cast<SpvOp>(5267)}, + {"OpSubgroupAvcImeGetDualReferenceStreaminINTEL", static_cast<SpvOp>(5767)}, + {"OpShiftRightArithmetic", static_cast<SpvOp>(195)}, + {"OpSUDotAccSatKHR", static_cast<SpvOp>(4455)}, + {"OpArbitraryFloatPowNINTEL", static_cast<SpvOp>(5882)}, + {"OpDecorateString", static_cast<SpvOp>(5632)}, + {"OpReservedReadPipe", static_cast<SpvOp>(276)}, + {"OpBitcast", static_cast<SpvOp>(124)}, + {"OpSubgroupImageBlockWriteINTEL", static_cast<SpvOp>(5578)}, + {"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", static_cast<SpvOp>(5802)}, + {"OpSubgroupShuffleUpINTEL", static_cast<SpvOp>(5573)}, + {"OpArrayLength", static_cast<SpvOp>(68)}, + {"OpRayQueryProceedKHR", static_cast<SpvOp>(4477)}, + {"OpAbsUSubINTEL", static_cast<SpvOp>(5588)}, + {"OpGroupNonUniformBallotBitCount", static_cast<SpvOp>(342)}, + {"OpFunctionPointerCallINTEL", static_cast<SpvOp>(5601)}, + {"OpArbitraryFloatHypotINTEL", static_cast<SpvOp>(5858)}, + {"OpGetKernelNDrangeSubGroupCount", static_cast<SpvOp>(293)}, + {"OpFunctionParameter", static_cast<SpvOp>(55)}, + {"OpFwidthCoarse", static_cast<SpvOp>(215)}, + {"OpUDotAccSatKHR", static_cast<SpvOp>(4454)}, + {"OpFOrdLessThanEqual", static_cast<SpvOp>(188)}, + {"OpAtomicISub", static_cast<SpvOp>(235)}, + {"OpHitObjectGetWorldRayDirectionNV", static_cast<SpvOp>(5272)}, + {"OpNoLine", static_cast<SpvOp>(317)}, + {"OpConvertFToBF16INTEL", static_cast<SpvOp>(6116)}, + {"OpFMul", static_cast<SpvOp>(133)}, + {"OpLogicalEqual", static_cast<SpvOp>(164)}, + {"OpExecutionModeId", static_cast<SpvOp>(331)}, + {"OpArbitraryFloatLog10INTEL", static_cast<SpvOp>(5862)}, + {"OpIAdd", static_cast<SpvOp>(128)}, + {"OpColorAttachmentReadEXT", static_cast<SpvOp>(4160)}, + {"OpGroupFMaxNonUniformAMD", static_cast<SpvOp>(5005)}, + {"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", static_cast<SpvOp>(5729)}, + {"OpReorderThreadWithHintNV", static_cast<SpvOp>(5280)}, + {"OpULessThan", static_cast<SpvOp>(176)}, + {"OpSubgroupAvcMceGetInterMajorShapeINTEL", static_cast<SpvOp>(5741)}, + {"OpLine", static_cast<SpvOp>(8)}, + {"OpArbitraryFloatLTINTEL", static_cast<SpvOp>(5852)}, + {"OpAtomicIDecrement", static_cast<SpvOp>(233)}, + {"OpArbitraryFloatSqrtINTEL", static_cast<SpvOp>(5859)}, + {"OpPtrNotEqual", static_cast<SpvOp>(402)}, + {"OpHitObjectRecordHitMotionNV", static_cast<SpvOp>(5249)}, + {"OpStore", static_cast<SpvOp>(62)}, + {"OpArbitraryFloatATan2INTEL", static_cast<SpvOp>(5879)}, + {"OpGroupNonUniformQuadBroadcast", static_cast<SpvOp>(365)}, + {"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", static_cast<SpvOp>(5730)}, + {"OpUMulExtended", static_cast<SpvOp>(151)}, + {"OpGroupFAdd", static_cast<SpvOp>(265)}, + {"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", static_cast<SpvOp>(5727)}, + {"OpCopyObject", static_cast<SpvOp>(83)}, + {"OpVectorExtractDynamic", static_cast<SpvOp>(77)}, + {"OpEnqueueKernel", static_cast<SpvOp>(292)}, + {"OpTypeQueue", static_cast<SpvOp>(37)}, + {"OpSubgroupAvcImeSetWeightedSadINTEL", static_cast<SpvOp>(5756)}, + {"OpTypeAvcMcePayloadINTEL", static_cast<SpvOp>(5704)}, + {"OpRayQueryInitializeKHR", static_cast<SpvOp>(4473)}, + {"OpArbitraryFloatGEINTEL", static_cast<SpvOp>(5851)}, + {"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", static_cast<SpvOp>(5814)}, + {"OpFSub", static_cast<SpvOp>(131)}, + {"OpHitObjectRecordHitWithIndexNV", static_cast<SpvOp>(5262)}, + {"OpSpecConstantOp", static_cast<SpvOp>(52)}, + {"OpGroupNonUniformFMul", static_cast<SpvOp>(352)}, + {"OpHitObjectGetInstanceIdNV", static_cast<SpvOp>(5270)}, + {"OpSubgroupAvcMceConvertToRefPayloadINTEL", static_cast<SpvOp>(5734)}, + {"OpFunctionEnd", static_cast<SpvOp>(56)}, + {"OpGroupFMinNonUniformAMD", static_cast<SpvOp>(5002)}, + {"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", static_cast<SpvOp>(5815)}, + {"OpArbitraryFloatCbrtINTEL", static_cast<SpvOp>(5857)}, + {"OpImageBlockMatchSSDQCOM", static_cast<SpvOp>(4482)}, + {"OpEndPrimitive", static_cast<SpvOp>(219)}, + {"OpIsHelperInvocationEXT", static_cast<SpvOp>(5381)}, + {"OpImageWrite", static_cast<SpvOp>(99)}, + {"OpGetNumPipePackets", static_cast<SpvOp>(283)}, + {"OpConstant", static_cast<SpvOp>(43)}, + {"OpGenericCastToPtrExplicit", static_cast<SpvOp>(123)}, + {"OpSubgroupAvcMceGetInterDistortionsINTEL", static_cast<SpvOp>(5739)}, + {"OpCooperativeMatrixStoreNV", static_cast<SpvOp>(5360)}, + {"OpGroupDecorate", static_cast<SpvOp>(74)}, + {"OpAbsISubINTEL", static_cast<SpvOp>(5587)}, + {"OpVariable", static_cast<SpvOp>(59)}, + {"OpDPdxCoarse", static_cast<SpvOp>(213)}, + {"OpSDotAccSatKHR", static_cast<SpvOp>(4453)}, + {"OpDemoteToHelperInvocation", static_cast<SpvOp>(5380)}, + {"OpHitObjectRecordHitNV", static_cast<SpvOp>(5261)}, + {"OpSubgroupAvcSicConvertToMcePayloadINTEL", static_cast<SpvOp>(5796)}, + {"OpRayQueryGetIntersectionPrimitiveIndexKHR", static_cast<SpvOp>(6023)}, + {"OpTypeArray", static_cast<SpvOp>(28)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", static_cast<SpvOp>(5761)}, + {"OpRayQueryGetIntersectionInstanceIdKHR", static_cast<SpvOp>(6020)}, + {"OpCrossWorkgroupCastToPtrINTEL", static_cast<SpvOp>(5938)}, + {"OpTypeAvcImeResultSingleReferenceStreamoutINTEL", static_cast<SpvOp>(5707)}, + {"OpArbitraryFloatLogINTEL", static_cast<SpvOp>(5860)}, + {"OpGroupNonUniformQuadSwap", static_cast<SpvOp>(366)}, + {"OpVmeImageINTEL", static_cast<SpvOp>(5699)}, + {"OpFixedRsqrtINTEL", static_cast<SpvOp>(5925)}, + {"OpUCountLeadingZerosINTEL", static_cast<SpvOp>(5585)}, + {"OpAtomicFMaxEXT", static_cast<SpvOp>(5615)}, + {"OpControlBarrier", static_cast<SpvOp>(224)}, + {"OpSatConvertSToU", static_cast<SpvOp>(118)}, + {"OpTypeAvcRefResultINTEL", static_cast<SpvOp>(5711)}, + {"OpArbitraryFloatLog2INTEL", static_cast<SpvOp>(5861)}, + {"OpGroupSMax", static_cast<SpvOp>(271)}, + {"OpTypePipe", static_cast<SpvOp>(38)}, + {"OpAtomicUMax", static_cast<SpvOp>(239)}, + {"OpTypeImage", static_cast<SpvOp>(25)}, + {"OpReadPipe", static_cast<SpvOp>(274)}, + {"OpGroupNonUniformBroadcast", static_cast<SpvOp>(337)}, + {"OpTypeFunction", static_cast<SpvOp>(33)}, + {"OpTypeAvcImePayloadINTEL", static_cast<SpvOp>(5701)}, + {"OpCreateUserEvent", static_cast<SpvOp>(299)}, + {"OpSubgroupAvcBmeInitializeINTEL", static_cast<SpvOp>(5782)}, + {"OpAtomicCompareExchangeWeak", static_cast<SpvOp>(231)}, + {"OpSampledImage", static_cast<SpvOp>(86)}, + {"OpConvertBF16ToFINTEL", static_cast<SpvOp>(6117)}, + {"OpSubgroupAvcSicEvaluateIpeINTEL", static_cast<SpvOp>(5803)}, + {"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", static_cast<SpvOp>(5780)}, + {"OpAsmINTEL", static_cast<SpvOp>(5610)}, + {"OpKill", static_cast<SpvOp>(252)}, + {"OpGroupNonUniformShuffleDown", static_cast<SpvOp>(348)}, + {"OpArbitraryFloatRecipINTEL", static_cast<SpvOp>(5855)}, + {"OpIAverageRoundedINTEL", static_cast<SpvOp>(5593)}, + {"OpUAddSatINTEL", static_cast<SpvOp>(5590)}, + {"OpGroupNonUniformShuffle", static_cast<SpvOp>(345)}, + {"OpDecorateId", static_cast<SpvOp>(332)}, + {"OpArbitraryFloatExpm1INTEL", static_cast<SpvOp>(5867)}, + {"OpGroupBitwiseXorKHR", static_cast<SpvOp>(6405)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", static_cast<SpvOp>(5763)}, + {"OpArbitraryFloatASinPiINTEL", static_cast<SpvOp>(5874)}, + {"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", static_cast<SpvOp>(5797)}, + {"OpIsNormal", static_cast<SpvOp>(159)}, + {"OpIEqual", static_cast<SpvOp>(170)}, + {"OpArbitraryFloatACosPiINTEL", static_cast<SpvOp>(5876)}, + {"OpGroupNonUniformIMul", static_cast<SpvOp>(351)}, + {"OpMatrixTimesVector", static_cast<SpvOp>(145)}, + {"OpSetMeshOutputsEXT", static_cast<SpvOp>(5295)}, + {"OpFragmentFetchAMD", static_cast<SpvOp>(5012)}, + {"OpShiftLeftLogical", static_cast<SpvOp>(196)}, + {"OpSubgroupAvcRefConvertToMceResultINTEL", static_cast<SpvOp>(5790)}, + {"OpDemoteToHelperInvocationEXT", static_cast<SpvOp>(5380)}, + {"OpInBoundsAccessChain", static_cast<SpvOp>(66)}, + {"OpCooperativeMatrixMulAddKHR", static_cast<SpvOp>(4459)}, + {"OpAtomicIAdd", static_cast<SpvOp>(234)}, + {"OpCopyMemorySized", static_cast<SpvOp>(64)}, + {"OpSubgroupAvcMceGetInterMinorShapeINTEL", static_cast<SpvOp>(5742)}, + {"OpImageSparseRead", static_cast<SpvOp>(320)}, + {"OpTypeAvcRefPayloadINTEL", static_cast<SpvOp>(5702)}, + {"OpArbitraryFloatExp10INTEL", static_cast<SpvOp>(5866)}, + {"OpTypeAvcSicPayloadINTEL", static_cast<SpvOp>(5703)}, + {"OpConvertFToS", static_cast<SpvOp>(110)}, + {"OpISubSatINTEL", static_cast<SpvOp>(5595)}, + {"OpVariableLengthArrayINTEL", static_cast<SpvOp>(5818)}, + {"OpRayQueryGetIntersectionTriangleVertexPositionsKHR", static_cast<SpvOp>(5340)}, + {"OpGroupNonUniformAllEqual", static_cast<SpvOp>(336)}, + {"OpIsInf", static_cast<SpvOp>(157)}, + {"OpIgnoreIntersectionKHR", static_cast<SpvOp>(4448)}, + {"OpImageGather", static_cast<SpvOp>(96)}, + {"OpRayQueryGetRayFlagsKHR", static_cast<SpvOp>(6017)}, + {"OpGroupNonUniformShuffleUp", static_cast<SpvOp>(347)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", static_cast<SpvOp>(5760)}, + {"OpRayQueryGetIntersectionTKHR", static_cast<SpvOp>(6018)}, + {"OpHitObjectGetAttributesNV", static_cast<SpvOp>(5266)}, + {"OpFUnordLessThanEqual", static_cast<SpvOp>(189)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", static_cast<SpvOp>(5757)}, + {"OpHitObjectGetObjectRayDirectionNV", static_cast<SpvOp>(5254)}, + {"OpCooperativeMatrixStoreKHR", static_cast<SpvOp>(4458)}, + {"OpSubgroupAvcMceSetInterShapePenaltyINTEL", static_cast<SpvOp>(5716)}, + {"OpModuleProcessed", static_cast<SpvOp>(330)}, + {"OpEmitStreamVertex", static_cast<SpvOp>(220)}, + {"OpMemoryModel", static_cast<SpvOp>(14)}, + {"OpDepthAttachmentReadEXT", static_cast<SpvOp>(4161)}, + {"OpGroupNonUniformUMax", static_cast<SpvOp>(357)}, + {"OpFwidthFine", static_cast<SpvOp>(212)}, + {"OpImageSampleExplicitLod", static_cast<SpvOp>(88)}, + {"OpUGreaterThanEqual", static_cast<SpvOp>(174)}, + {"OpSubgroupShuffleDownINTEL", static_cast<SpvOp>(5572)}, + {"OpHitObjectRecordHitWithIndexMotionNV", static_cast<SpvOp>(5250)}, + {"OpIAverageINTEL", static_cast<SpvOp>(5591)}, + {"OpFRem", static_cast<SpvOp>(140)}, + {"OpSubgroupAvcImeAdjustRefOffsetINTEL", static_cast<SpvOp>(5751)}, + {"OpSwitch", static_cast<SpvOp>(251)}, + {"OpBitwiseAnd", static_cast<SpvOp>(199)}, + {"OpUMod", static_cast<SpvOp>(137)}, + {"OpAtomicXor", static_cast<SpvOp>(242)}, + {"OpFAdd", static_cast<SpvOp>(129)}, + {"OpRestoreMemoryINTEL", static_cast<SpvOp>(5820)}, + {"OpPtrCastToCrossWorkgroupINTEL", static_cast<SpvOp>(5934)}, + {"OpImageRead", static_cast<SpvOp>(98)}, + {"OpTypeAvcImeResultDualReferenceStreamoutINTEL", static_cast<SpvOp>(5708)}, + {"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", static_cast<SpvOp>(5805)}, + {"OpCompositeExtract", static_cast<SpvOp>(81)}, + {"OpSubgroupBlockReadINTEL", static_cast<SpvOp>(5575)}, + {"OpSubgroupAvcMceConvertToImeResultINTEL", static_cast<SpvOp>(5733)}, + {"OpSubgroupAvcMceConvertToRefResultINTEL", static_cast<SpvOp>(5735)}, + {"OpGroupCommitReadPipe", static_cast<SpvOp>(287)}, + {"OpConvertFToU", static_cast<SpvOp>(109)}, + {"OpConvertUToF", static_cast<SpvOp>(112)}, + {"OpCommitReadPipe", static_cast<SpvOp>(280)}, + {"OpLabel", static_cast<SpvOp>(248)}, + {"OpGroupUMinNonUniformAMD", static_cast<SpvOp>(5003)}, + {"OpTypeNamedBarrier", static_cast<SpvOp>(327)}, + {"OpConvertPtrToU", static_cast<SpvOp>(117)}, + {"OpTypeVmeImageINTEL", static_cast<SpvOp>(5700)}, + {"OpTypeVector", static_cast<SpvOp>(23)}, + {"OpGroupNonUniformLogicalXor", static_cast<SpvOp>(364)}, + {"OpSignBitSet", static_cast<SpvOp>(160)}, + {"OpGetMaxPipePackets", static_cast<SpvOp>(284)}, + {"OpSubgroupImageMediaBlockReadINTEL", static_cast<SpvOp>(5580)}, + {"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", static_cast<SpvOp>(5778)}, + {"OpArbitraryFloatCosPiINTEL", static_cast<SpvOp>(5872)}, + {"OpReturn", static_cast<SpvOp>(253)}, + {"OpFixedSinPiINTEL", static_cast<SpvOp>(5929)}, + {"OpGetKernelMaxNumSubgroups", static_cast<SpvOp>(326)}, + {"OpTypeDeviceEvent", static_cast<SpvOp>(35)}, + {"OpSubgroupAvcSicConfigureIpeLumaINTEL", static_cast<SpvOp>(5793)}, + {"OpArbitraryFloatASinINTEL", static_cast<SpvOp>(5873)}, + {"OpArbitraryFloatSinINTEL", static_cast<SpvOp>(5868)}, + {"OpArbitraryFloatATanPiINTEL", static_cast<SpvOp>(5878)}, + {"OpArbitraryFloatCastFromIntINTEL", static_cast<SpvOp>(5842)}, + {"OpHitObjectGetCurrentTimeNV", static_cast<SpvOp>(5265)}, + {"OpFMod", static_cast<SpvOp>(141)}, + {"OpAtomicSMax", static_cast<SpvOp>(238)}, + {"OpGroupNonUniformBitwiseXor", static_cast<SpvOp>(361)}, + {"OpUDotAccSat", static_cast<SpvOp>(4454)}, + {"OpGroupSMinNonUniformAMD", static_cast<SpvOp>(5004)}, + {"OpSubgroupAvcImeSetDualReferenceINTEL", static_cast<SpvOp>(5749)}, + {"OpGroupAny", static_cast<SpvOp>(262)}, + {"OpTypeStructContinuedINTEL", static_cast<SpvOp>(6090)}, + {"OpTraceRayMotionNV", static_cast<SpvOp>(5339)}, + {"OpHitObjectGetObjectToWorldNV", static_cast<SpvOp>(5253)}, + {"OpGetKernelWorkGroupSize", static_cast<SpvOp>(295)}, + {"OpFConvert", static_cast<SpvOp>(115)}, + {"OpArbitraryFloatEQINTEL", static_cast<SpvOp>(5854)}, + {"OpSubgroupAvcImeSetSingleReferenceINTEL", static_cast<SpvOp>(5748)}, + {"OpGroupAll", static_cast<SpvOp>(261)}, + {"OpCooperativeMatrixLengthKHR", static_cast<SpvOp>(4460)}, + {"OpSMod", static_cast<SpvOp>(139)}, + {"OpConvertSToF", static_cast<SpvOp>(111)}, + {"OpImageQuerySamples", static_cast<SpvOp>(107)}, + {"OpInBoundsPtrAccessChain", static_cast<SpvOp>(70)}, + {"OpNot", static_cast<SpvOp>(200)}, + {"OpUGreaterThan", static_cast<SpvOp>(172)}, + {"OpSubgroupAvcMceConvertToSicPayloadINTEL", static_cast<SpvOp>(5736)}, + {"OpSubgroupAvcSicSetBilinearFilterEnableINTEL", static_cast<SpvOp>(5800)}, + {"OpRayQueryGetIntersectionTypeKHR", static_cast<SpvOp>(4479)}, + {"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", static_cast<SpvOp>(5801)}, + {"OpImageSampleImplicitLod", static_cast<SpvOp>(87)}, + {"OpHitObjectGetRayTMinNV", static_cast<SpvOp>(5275)}, + {"OpGroupNonUniformBallotFindLSB", static_cast<SpvOp>(343)}, + {"OpName", static_cast<SpvOp>(5)}, + {"OpConvertUToPtr", static_cast<SpvOp>(120)}, + {"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", static_cast<SpvOp>(5720)}, + {"OpAtomicOr", static_cast<SpvOp>(241)}, + {"OpSubgroupAnyKHR", static_cast<SpvOp>(4429)}, + {"OpSelect", static_cast<SpvOp>(169)}, + {"OpImageSparseSampleProjDrefImplicitLod", static_cast<SpvOp>(311)}, + {"OpFOrdLessThan", static_cast<SpvOp>(184)}, + {"OpSDotKHR", static_cast<SpvOp>(4450)}, + {"OpGroupReserveReadPipePackets", static_cast<SpvOp>(285)}, + {"OpLogicalNotEqual", static_cast<SpvOp>(165)}, + {"OpControlBarrierArriveINTEL", static_cast<SpvOp>(6142)}, + {"OpDPdxFine", static_cast<SpvOp>(210)}, + {"OpGroupNonUniformPartitionNV", static_cast<SpvOp>(5296)}, + {"OpImageBoxFilterQCOM", static_cast<SpvOp>(4481)}, + {"OpRayQueryGetIntersectionWorldToObjectKHR", static_cast<SpvOp>(6032)}, + {"OpSubgroupAvcSicGetInterRawSadsINTEL", static_cast<SpvOp>(5816)}, + {"OpSRem", static_cast<SpvOp>(138)}, + {"OpSizeOf", static_cast<SpvOp>(321)}, + {"OpUDot", static_cast<SpvOp>(4451)}, + {"OpReleaseEvent", static_cast<SpvOp>(298)}, + {"OpIgnoreIntersectionNV", static_cast<SpvOp>(5335)}, + {"OpFOrdNotEqual", static_cast<SpvOp>(182)}, + {"OpFOrdGreaterThanEqual", static_cast<SpvOp>(190)}, + {"OpAll", static_cast<SpvOp>(155)}, + {"OpExpectKHR", static_cast<SpvOp>(5631)}, + {"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", static_cast<SpvOp>(5731)}, + {"OpCompositeInsert", static_cast<SpvOp>(82)}, + {"OpImageSparseSampleImplicitLod", static_cast<SpvOp>(305)}, + {"OpFixedLogINTEL", static_cast<SpvOp>(5932)}, + {"OpMatrixTimesMatrix", static_cast<SpvOp>(146)}, + {"OpTypeOpaque", static_cast<SpvOp>(31)}, + {"OpCooperativeMatrixLengthNV", static_cast<SpvOp>(5362)}, + {"OpExecuteCallableKHR", static_cast<SpvOp>(4446)}, + {"OpImageDrefGather", static_cast<SpvOp>(97)}, + {"OpFUnordLessThan", static_cast<SpvOp>(185)}, + {"OpPtrAccessChain", static_cast<SpvOp>(67)}, + {"OpTypeForwardPointer", static_cast<SpvOp>(39)}, + {"OpAtomicCompareExchange", static_cast<SpvOp>(230)}, + {"OpCooperativeMatrixLoadNV", static_cast<SpvOp>(5359)}, + {"OpSubgroupAvcMceConvertToSicResultINTEL", static_cast<SpvOp>(5737)}, + {"OpFragmentMaskFetchAMD", static_cast<SpvOp>(5011)}, + {"OpImageSparseFetch", static_cast<SpvOp>(313)}, + {"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", static_cast<SpvOp>(5759)}, + {"OpReadClockKHR", static_cast<SpvOp>(5056)}, + {"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", static_cast<SpvOp>(5789)}, + {"OpSubgroupAllEqualKHR", static_cast<SpvOp>(4430)}, + {"OpFNegate", static_cast<SpvOp>(127)}, + {"OpArbitraryFloatGTINTEL", static_cast<SpvOp>(5850)}, + {"OpReportIntersectionNV", static_cast<SpvOp>(5334)}, + {"OpUCountTrailingZerosINTEL", static_cast<SpvOp>(5586)}, + {"OpBitFieldUExtract", static_cast<SpvOp>(203)}, + {"OpCompositeConstruct", static_cast<SpvOp>(80)}, + {"OpImageSparseGather", static_cast<SpvOp>(314)}, + {"OpImageSparseSampleDrefExplicitLod", static_cast<SpvOp>(308)}, + {"OpGetKernelLocalSizeForSubgroupCount", static_cast<SpvOp>(325)}, + {"OpNop", static_cast<SpvOp>(0)}, + {"OpTypeAvcSicResultINTEL", static_cast<SpvOp>(5712)}, + {"OpAtomicSMin", static_cast<SpvOp>(236)}, + {"OpLoad", static_cast<SpvOp>(61)}, + {"OpIsNan", static_cast<SpvOp>(156)}, + {"OpAny", static_cast<SpvOp>(154)}, + {"OpIAddCarry", static_cast<SpvOp>(149)}, + {"OpExtInstImport", static_cast<SpvOp>(11)}, + {"OpLoopControlINTEL", static_cast<SpvOp>(5887)}, + {"OpSubgroupAvcImeConvertToMceResultINTEL", static_cast<SpvOp>(5765)}, + {"OpGroupNonUniformSMax", static_cast<SpvOp>(356)}, + {"OpGroupSMin", static_cast<SpvOp>(268)}, + {"OpConstantPipeStorage", static_cast<SpvOp>(323)}, + {"OpIsValidReserveId", static_cast<SpvOp>(282)}, + {"OpAliasScopeListDeclINTEL", static_cast<SpvOp>(5913)}, + {"OpConvertUToAccelerationStructureKHR", static_cast<SpvOp>(4447)}, + {"OpArbitraryFloatCastINTEL", static_cast<SpvOp>(5841)}, + {"OpHitObjectGetShaderBindingTableRecordIndexNV", static_cast<SpvOp>(5258)}, + {"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", static_cast<SpvOp>(5768)}, + {"OpSubgroupBallotKHR", static_cast<SpvOp>(4421)}, + {"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", static_cast<SpvOp>(5810)}, + {"OpGroupNonUniformBallotFindMSB", static_cast<SpvOp>(344)}, + {"OpTypeMatrix", static_cast<SpvOp>(24)}, + {"OpTraceMotionNV", static_cast<SpvOp>(5338)}, + {"OpGroupLogicalXorKHR", static_cast<SpvOp>(6408)}, + {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", static_cast<SpvOp>(5771)}, + {"OpRayQueryConfirmIntersectionKHR", static_cast<SpvOp>(4476)}, + {"OpArbitraryFloatRSqrtINTEL", static_cast<SpvOp>(5856)}, + {"OpRayQueryGetRayTMinKHR", static_cast<SpvOp>(6016)}, + {"OpUMul32x16INTEL", static_cast<SpvOp>(5598)}, + {"OpReadPipeBlockingINTEL", static_cast<SpvOp>(5946)}, + {"OpHitObjectIsEmptyNV", static_cast<SpvOp>(5276)}, + {"OpImageSampleFootprintNV", static_cast<SpvOp>(5283)}, + {"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", static_cast<SpvOp>(5798)}, + {"OpGroupLogicalOrKHR", static_cast<SpvOp>(6407)}, + {"OpAtomicFlagClear", static_cast<SpvOp>(319)}, + {"OpBeginInvocationInterlockEXT", static_cast<SpvOp>(5364)}, + {"OpVectorInsertDynamic", static_cast<SpvOp>(78)}, + {"OpRayQueryGetIntersectionBarycentricsKHR", static_cast<SpvOp>(6024)}, + {"OpArbitraryFloatSubINTEL", static_cast<SpvOp>(5847)}, + {"OpConvertSampledImageToUNV", static_cast<SpvOp>(5396)}, + {"OpTypeAvcImeDualReferenceStreaminINTEL", static_cast<SpvOp>(5710)}, + {"OpVectorTimesScalar", static_cast<SpvOp>(142)}, + {"OpImageSampleProjDrefImplicitLod", static_cast<SpvOp>(93)}, + {"OpTypeAvcImeSingleReferenceStreaminINTEL", static_cast<SpvOp>(5709)}, + {"OpImageSparseSampleProjDrefExplicitLod", static_cast<SpvOp>(312)}, + {"OpAtomicLoad", static_cast<SpvOp>(227)}, + {"OpTypeFloat", static_cast<SpvOp>(22)}, + {"OpGroupNonUniformUMin", static_cast<SpvOp>(354)}, + {"OpSubgroupAvcMceSetAcOnlyHaarINTEL", static_cast<SpvOp>(5728)}, + {"OpTypeSampler", static_cast<SpvOp>(26)}, + {"OpTypeAccelerationStructureKHR", static_cast<SpvOp>(5341)}, + {"OpGroupIAddNonUniformAMD", static_cast<SpvOp>(5000)}, + {"OpFixedSinCosINTEL", static_cast<SpvOp>(5928)}, + {"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", static_cast<SpvOp>(5723)}, + {"OpGroupNonUniformAll", static_cast<SpvOp>(334)}, + {"OpArbitraryFloatCastToIntINTEL", static_cast<SpvOp>(5843)}, + {"OpGroupNonUniformShuffleXor", static_cast<SpvOp>(346)}, + {"OpGroupUMin", static_cast<SpvOp>(267)}, + {"OpUndef", static_cast<SpvOp>(1)}, + {"OpTerminateRayNV", static_cast<SpvOp>(5336)}, + {"OpTypeVoid", static_cast<SpvOp>(19)}, + {"OpRayQueryGetIntersectionObjectToWorldKHR", static_cast<SpvOp>(6031)}, + {"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", static_cast<SpvOp>(5773)}, + {"OpTypePointer", static_cast<SpvOp>(32)}, + {"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", static_cast<SpvOp>(5807)}, + {"OpTranspose", static_cast<SpvOp>(84)}, + {"OpGroupSMaxNonUniformAMD", static_cast<SpvOp>(5007)}, + {"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", static_cast<SpvOp>(5769)}, + {"OpSubgroupAvcFmeInitializeINTEL", static_cast<SpvOp>(5781)}, + {"OpPtrCastToGeneric", static_cast<SpvOp>(121)}, + {"OpRetainEvent", static_cast<SpvOp>(297)}, + {"OpConstantNull", static_cast<SpvOp>(46)}, + {"OpImageSparseSampleDrefImplicitLod", static_cast<SpvOp>(307)}, + {"OpArbitraryFloatACosINTEL", static_cast<SpvOp>(5875)}, + {"OpExecuteCallableNV", static_cast<SpvOp>(5344)}, + {"OpTerminateRayKHR", static_cast<SpvOp>(4449)}, + {"OpImageSampleDrefImplicitLod", static_cast<SpvOp>(89)}, + {"OpImageSampleProjExplicitLod", static_cast<SpvOp>(92)}, + {"OpGroupNonUniformInverseBallot", static_cast<SpvOp>(340)}, + {"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", static_cast<SpvOp>(5717)}, + {"OpMemberDecorate", static_cast<SpvOp>(72)}, + {"OpHitObjectRecordEmptyNV", static_cast<SpvOp>(5259)}, + {"OpImageQueryLevels", static_cast<SpvOp>(106)}, + {"OpSDot", static_cast<SpvOp>(4450)}, + {"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", static_cast<SpvOp>(5766)}, + {"OpFixedExpINTEL", static_cast<SpvOp>(5933)}, + {"OpHitObjectGetPrimitiveIndexNV", static_cast<SpvOp>(5268)}, + {"OpTypeRuntimeArray", static_cast<SpvOp>(29)}, + {"OpHitObjectGetShaderRecordBufferHandleNV", static_cast<SpvOp>(5257)}, + {"OpSubgroupAvcMceConvertToImePayloadINTEL", static_cast<SpvOp>(5732)}, + {"OpCaptureEventProfilingInfo", static_cast<SpvOp>(302)}, + {"OpRayQueryGetWorldRayDirectionKHR", static_cast<SpvOp>(6029)}, + {"OpConstantFalse", static_cast<SpvOp>(42)}, + {"OpArbitraryFloatLog1pINTEL", static_cast<SpvOp>(5863)}, + {"OpHitObjectIsMissNV", static_cast<SpvOp>(5278)}, + {"OpWritePipeBlockingINTEL", static_cast<SpvOp>(5947)}, + {"OpTypeCooperativeMatrixNV", static_cast<SpvOp>(5358)}, + {"OpSubgroupShuffleXorINTEL", static_cast<SpvOp>(5574)}, + {"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", static_cast<SpvOp>(5753)}, + {"OpTypeInt", static_cast<SpvOp>(21)}, + {"OpSubgroupAvcImeInitializeINTEL", static_cast<SpvOp>(5747)}, + {"OpMemoryNamedBarrier", static_cast<SpvOp>(329)}, + {"OpConstantComposite", static_cast<SpvOp>(44)}, + {"OpHitObjectGetInstanceCustomIndexNV", static_cast<SpvOp>(5271)}, + {"OpGroupWaitEvents", static_cast<SpvOp>(260)}, + {"OpSubgroupAllKHR", static_cast<SpvOp>(4428)}, + {"OpSubgroupImageMediaBlockWriteINTEL", static_cast<SpvOp>(5581)}, + {"OpSatConvertUToS", static_cast<SpvOp>(119)}, + {"OpArbitraryFloatCosINTEL", static_cast<SpvOp>(5869)}, + {"OpSetUserEventStatus", static_cast<SpvOp>(301)}, + {"OpGroupNonUniformIAdd", static_cast<SpvOp>(349)}, + {"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", static_cast<SpvOp>(5804)}, + {"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", static_cast<SpvOp>(5788)}, + {"OpGroupUMaxNonUniformAMD", static_cast<SpvOp>(5006)}, + {"OpRayQueryGetIntersectionObjectRayOriginKHR", static_cast<SpvOp>(6028)}, + {"OpGetKernelPreferredWorkGroupSizeMultiple", static_cast<SpvOp>(296)}, + {"OpSubgroupAvcSicGetMotionVectorMaskINTEL", static_cast<SpvOp>(5795)}, + {"OpConstantFunctionPointerINTEL", static_cast<SpvOp>(5600)}, + {"OpAsmTargetINTEL", static_cast<SpvOp>(5609)}, + {"OpOrdered", static_cast<SpvOp>(162)}, + {"OpFPGARegINTEL", static_cast<SpvOp>(5949)}, + {"OpFixedSinINTEL", static_cast<SpvOp>(5926)}, + {"OpRayQueryGetIntersectionGeometryIndexKHR", static_cast<SpvOp>(6022)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", static_cast<SpvOp>(5762)}, + {"OpUnreachable", static_cast<SpvOp>(255)}, + {"OpSource", static_cast<SpvOp>(3)}, + {"OpSamplerImageAddressingModeNV", static_cast<SpvOp>(5397)}, + {"OpExtension", static_cast<SpvOp>(10)}, + {"OpBitFieldInsert", static_cast<SpvOp>(201)}, + {"OpCreatePipeFromPipeStorage", static_cast<SpvOp>(324)}, + {"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", static_cast<SpvOp>(5786)}, + {"OpReserveWritePipePackets", static_cast<SpvOp>(279)}, + {"OpTypeHitObjectNV", static_cast<SpvOp>(5281)}, + {"OpTypeRayQueryKHR", static_cast<SpvOp>(4472)}, + {"OpAtomicIIncrement", static_cast<SpvOp>(232)}, + {"OpGroupIMulKHR", static_cast<SpvOp>(6401)}, + {"OpExecutionMode", static_cast<SpvOp>(16)}, + {"OpTypeReserveId", static_cast<SpvOp>(36)}, + {"OpImageQueryFormat", static_cast<SpvOp>(101)}, + {"OpBitwiseXor", static_cast<SpvOp>(198)}, + {"OpSpecConstant", static_cast<SpvOp>(50)}, + {"OpSGreaterThan", static_cast<SpvOp>(173)}, + {"OpIAddSatINTEL", static_cast<SpvOp>(5589)}, + {"OpSourceExtension", static_cast<SpvOp>(4)}, + {"OpFUnordGreaterThanEqual", static_cast<SpvOp>(191)}, + {"OpEndInvocationInterlockEXT", static_cast<SpvOp>(5365)}, + {"OpSourceContinued", static_cast<SpvOp>(2)}, + {"OpCooperativeMatrixMulAddNV", static_cast<SpvOp>(5361)}, + {"OpAtomicExchange", static_cast<SpvOp>(229)}, + {"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", static_cast<SpvOp>(5721)}, + {"OpUAverageRoundedINTEL", static_cast<SpvOp>(5594)}, + {"OpSubgroupAvcSicGetIpeChromaModeINTEL", static_cast<SpvOp>(5813)}, + {"OpUnordered", static_cast<SpvOp>(163)}, + {"OpWritePipe", static_cast<SpvOp>(275)}, + {"OpSelectionMerge", static_cast<SpvOp>(247)}, + {"OpPtrEqual", static_cast<SpvOp>(401)}, + {"OpTypeBool", static_cast<SpvOp>(20)}, + {"OpRayQueryGetIntersectionObjectRayDirectionKHR", static_cast<SpvOp>(6027)}, + {"OpGroupNonUniformFAdd", static_cast<SpvOp>(350)}, + {"OpTypeSampledImage", static_cast<SpvOp>(27)}, + {"OpSubgroupAvcSicInitializeINTEL", static_cast<SpvOp>(5791)}, + {"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", static_cast<SpvOp>(5779)}, + {"OpGroupBroadcast", static_cast<SpvOp>(263)}, + {"OpSaveMemoryINTEL", static_cast<SpvOp>(5819)}, + {"OpConstantTrue", static_cast<SpvOp>(41)}, + {"OpImageSampleDrefExplicitLod", static_cast<SpvOp>(90)}, + {"OpHitObjectTraceRayMotionNV", static_cast<SpvOp>(5256)}, + {"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", static_cast<SpvOp>(6026)}, + {"OpSpecConstantTrue", static_cast<SpvOp>(48)}, + {"OpBranch", static_cast<SpvOp>(249)}, + {"OpStencilAttachmentReadEXT", static_cast<SpvOp>(4162)}, + {"OpHitObjectExecuteShaderNV", static_cast<SpvOp>(5264)}, + {"OpGroupNonUniformBallot", static_cast<SpvOp>(339)}, + {"OpGroupReserveWritePipePackets", static_cast<SpvOp>(286)}, + {"OpImageSparseTexelsResident", static_cast<SpvOp>(316)}, + {"OpGroupFMax", static_cast<SpvOp>(269)}, + {"OpWritePackedPrimitiveIndices4x8NV", static_cast<SpvOp>(5299)}, + {"OpImageSparseDrefGather", static_cast<SpvOp>(315)}, + {"OpIMul32x16INTEL", static_cast<SpvOp>(5597)}, + {"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", static_cast<SpvOp>(5811)}, + {"OpISubBorrow", static_cast<SpvOp>(150)}, + {"OpArbitraryFloatSinPiINTEL", static_cast<SpvOp>(5871)}, + {"OpCopyMemory", static_cast<SpvOp>(63)}, + {"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", static_cast<SpvOp>(5812)}, + {"OpGroupNonUniformLogicalAnd", static_cast<SpvOp>(362)}, + {"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", static_cast<SpvOp>(5722)}, + {"OpFunctionCall", static_cast<SpvOp>(57)}, + {"OpImageSampleProjDrefExplicitLod", static_cast<SpvOp>(94)}, + {"OpAtomicFMinEXT", static_cast<SpvOp>(5614)}, + {"OpSubgroupAvcMceGetInterReferenceIdsINTEL", static_cast<SpvOp>(5745)}, + {"OpFixedRecipINTEL", static_cast<SpvOp>(5924)}, + {"OpLogicalAnd", static_cast<SpvOp>(167)}, + {"OpConvertImageToUNV", static_cast<SpvOp>(5393)}, + {"OpCapability", static_cast<SpvOp>(17)}, + {"OpSubgroupAvcSicConvertToMceResultINTEL", static_cast<SpvOp>(5808)}, + {"OpArbitraryFloatAddINTEL", static_cast<SpvOp>(5846)}, + {"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", static_cast<SpvOp>(5806)}, + {"OpMemberName", static_cast<SpvOp>(6)}, + {"OpSubgroupShuffleINTEL", static_cast<SpvOp>(5571)}, + {"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", static_cast<SpvOp>(5713)}, + {"OpHitObjectGetRayTMaxNV", static_cast<SpvOp>(5274)}, + {"OpGroupNonUniformBitwiseAnd", static_cast<SpvOp>(359)}, + {"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", static_cast<SpvOp>(5758)}, + {"OpTraceNV", static_cast<SpvOp>(5337)}, + {"OpFDiv", static_cast<SpvOp>(136)}, + {"OpAtomicAnd", static_cast<SpvOp>(240)}, + {"OpDPdyFine", static_cast<SpvOp>(211)}, + {"OpULessThanEqual", static_cast<SpvOp>(178)}, + {"OpGroupNonUniformAny", static_cast<SpvOp>(335)}, + {"OpRayQueryGetIntersectionInstanceCustomIndexKHR", static_cast<SpvOp>(6019)}, + {"OpGroupLogicalAndKHR", static_cast<SpvOp>(6406)}, + {"OpHitObjectIsHitNV", static_cast<SpvOp>(5277)}, + {"OpSubgroupImageBlockReadINTEL", static_cast<SpvOp>(5577)}, + {"OpHitObjectGetWorldRayOriginNV", static_cast<SpvOp>(5273)}, + {"OpAliasScopeDeclINTEL", static_cast<SpvOp>(5912)}, + {"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", static_cast<SpvOp>(5799)}, + {"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", static_cast<SpvOp>(5777)}, + {"OpOuterProduct", static_cast<SpvOp>(147)}, + {"OpEnqueueMarker", static_cast<SpvOp>(291)}, + {"OpSubgroupAvcSicGetIpeLumaShapeINTEL", static_cast<SpvOp>(5809)}, + {"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", static_cast<SpvOp>(5718)}, + {"OpFixedSinCosPiINTEL", static_cast<SpvOp>(5931)}, + {"OpArbitraryFloatMulINTEL", static_cast<SpvOp>(5848)}, + {"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", static_cast<SpvOp>(5754)}, + {"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", static_cast<SpvOp>(5770)}, + {"OpGroupMemberDecorate", static_cast<SpvOp>(75)}, + {"OpConstantSampler", static_cast<SpvOp>(45)}, + {"OpGroupNonUniformBallotBitExtract", static_cast<SpvOp>(341)}, + {"OpRayQueryGetWorldRayOriginKHR", static_cast<SpvOp>(6030)}, + {"OpGroupBitwiseOrKHR", static_cast<SpvOp>(6404)}, + {"OpSubgroupAvcImeGetBorderReachedINTEL", static_cast<SpvOp>(5776)}, + {"OpLifetimeStart", static_cast<SpvOp>(256)}, + {"OpConvertUToSampledImageNV", static_cast<SpvOp>(5395)}, + {"OpAtomicFAddEXT", static_cast<SpvOp>(6035)}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 718; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool lookupSpvCapability(const UnownedStringSlice& str, SpvCapability& value) +{ + static const unsigned tableSalt[245] = { + 1, 2, 0, 1, 1, 1, 0, 0, 2, 2, 0, 0, 0, 8, 0, 5, + 0, 0, 0, 0, 3, 2, 0, 1, 7, 3, 5, 3, 1, 2, 1, 0, + 0, 0, 0, 0, 4, 0, 0, 2, 1, 23, 1, 0, 5, 2, 0, 1, + 19, 0, 3, 0, 4, 1, 0, 1, 0, 4, 0, 8, 4, 3, 1, 2, + 2, 1, 0, 3, 2, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 15, + 0, 0, 8, 2, 1, 0, 1, 2, 1, 1, 2, 0, 2, 1, 0, 9, + 0, 3, 2, 4, 2, 7, 1, 0, 5, 0, 0, 0, 1, 6, 0, 0, + 1, 6, 2, 5, 1, 0, 2, 0, 7, 0, 0, 2, 4, 1, 14, 6, + 0, 12, 0, 1, 0, 0, 0, 0, 4, 4, 25, 10, 0, 0, 0, 14, + 1, 1, 3, 0, 6, 14, 1, 0, 1, 5, 0, 0, 1, 0, 2, 0, + 2, 35, 0, 0, 4, 0, 0, 8, 1, 3, 4, 0, 7, 19, 2, 9, + 2, 2, 12, 7, 2, 6, 0, 5, 1, 0, 3, 4, 2, 3, 14, 1, + 0, 7, 2, 46, 5, 2, 0, 0, 14, 0, 57, 0, 14, 0, 3, 0, + 0, 0, 25, 0, 32, 24, 49, 24, 1, 0, 27, 0, 0, 5, 3, 0, + 63, 0, 0, 0, 104, 0, 0, 10, 0, 0, 83, 79, 45, 4, 0, 0, + 231, 8, 133, 0, 14 + }; + + using KV = std::pair<const char*, SpvCapability>; + + static const KV words[245] = + { + {"StoragePushConstant8", static_cast<SpvCapability>(4450)}, + {"UniformTexelBufferArrayNonUniformIndexing", static_cast<SpvCapability>(5311)}, + {"ImageBasic", static_cast<SpvCapability>(13)}, + {"DeviceGroup", static_cast<SpvCapability>(4437)}, + {"DotProduct", static_cast<SpvCapability>(6019)}, + {"AtomicStorageOps", static_cast<SpvCapability>(4445)}, + {"ShaderSMBuiltinsNV", static_cast<SpvCapability>(5373)}, + {"PhysicalStorageBufferAddresses", static_cast<SpvCapability>(5347)}, + {"FragmentBarycentricKHR", static_cast<SpvCapability>(5284)}, + {"RayTracingProvisionalKHR", static_cast<SpvCapability>(5353)}, + {"UniformBufferArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5306)}, + {"FPGAKernelAttributesv2INTEL", static_cast<SpvCapability>(6161)}, + {"FPGAArgumentInterfacesINTEL", static_cast<SpvCapability>(6174)}, + {"SampledRect", static_cast<SpvCapability>(37)}, + {"AtomicFloat64AddEXT", static_cast<SpvCapability>(6034)}, + {"DeviceEnqueue", static_cast<SpvCapability>(19)}, + {"ShadingRateNV", static_cast<SpvCapability>(5291)}, + {"FragmentShadingRateKHR", static_cast<SpvCapability>(4422)}, + {"RoundToInfinityINTEL", static_cast<SpvCapability>(5582)}, + {"FPFastMathModeINTEL", static_cast<SpvCapability>(5837)}, + {"AtomicFloat16AddEXT", static_cast<SpvCapability>(6095)}, + {"StorageImageWriteWithoutFormat", static_cast<SpvCapability>(56)}, + {"GroupNonUniformVote", static_cast<SpvCapability>(62)}, + {"StorageImageArrayDynamicIndexing", static_cast<SpvCapability>(31)}, + {"Int64Atomics", static_cast<SpvCapability>(12)}, + {"DotProductInput4x8Bit", static_cast<SpvCapability>(6017)}, + {"ArbitraryPrecisionFixedPointINTEL", static_cast<SpvCapability>(5922)}, + {"FPGALoopControlsINTEL", static_cast<SpvCapability>(5888)}, + {"IntegerFunctions2INTEL", static_cast<SpvCapability>(5584)}, + {"AsmINTEL", static_cast<SpvCapability>(5606)}, + {"ShaderViewportIndexLayerNV", static_cast<SpvCapability>(5254)}, + {"GroupUniformArithmeticKHR", static_cast<SpvCapability>(6400)}, + {"ComputeDerivativeGroupQuadsNV", static_cast<SpvCapability>(5288)}, + {"Pipes", static_cast<SpvCapability>(17)}, + {"Int8", static_cast<SpvCapability>(39)}, + {"MultiViewport", static_cast<SpvCapability>(57)}, + {"SampledImageArrayDynamicIndexing", static_cast<SpvCapability>(29)}, + {"VulkanMemoryModelKHR", static_cast<SpvCapability>(5345)}, + {"FragmentShaderSampleInterlockEXT", static_cast<SpvCapability>(5363)}, + {"DotProductInput4x8BitKHR", static_cast<SpvCapability>(6017)}, + {"CooperativeMatrixNV", static_cast<SpvCapability>(5357)}, + {"RoundingModeRTE", static_cast<SpvCapability>(4467)}, + {"DotProductInput4x8BitPackedKHR", static_cast<SpvCapability>(6018)}, + {"TextureBlockMatchQCOM", static_cast<SpvCapability>(4486)}, + {"ShaderViewportIndex", static_cast<SpvCapability>(70)}, + {"DemoteToHelperInvocationEXT", static_cast<SpvCapability>(5379)}, + {"GroupNonUniformShuffleRelative", static_cast<SpvCapability>(66)}, + {"Shader", static_cast<SpvCapability>(1)}, + {"FPGAClusterAttributesINTEL", static_cast<SpvCapability>(5904)}, + {"UniformBufferArrayNonUniformIndexing", static_cast<SpvCapability>(5306)}, + {"SampleRateShading", static_cast<SpvCapability>(35)}, + {"MemoryAccessAliasingINTEL", static_cast<SpvCapability>(5910)}, + {"Groups", static_cast<SpvCapability>(18)}, + {"StorageTexelBufferArrayDynamicIndexingEXT", static_cast<SpvCapability>(5305)}, + {"StorageUniform16", static_cast<SpvCapability>(4434)}, + {"FragmentFullyCoveredEXT", static_cast<SpvCapability>(5265)}, + {"PhysicalStorageBufferAddressesEXT", static_cast<SpvCapability>(5347)}, + {"MeshShadingEXT", static_cast<SpvCapability>(5283)}, + {"GroupNonUniformPartitionedNV", static_cast<SpvCapability>(5297)}, + {"ImageMSArray", static_cast<SpvCapability>(48)}, + {"StorageInputOutput16", static_cast<SpvCapability>(4436)}, + {"VariablePointers", static_cast<SpvCapability>(4442)}, + {"TileImageStencilReadAccessEXT", static_cast<SpvCapability>(4168)}, + {"SampledImageArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5307)}, + {"ShaderClockKHR", static_cast<SpvCapability>(5055)}, + {"SubgroupVoteKHR", static_cast<SpvCapability>(4431)}, + {"StorageBufferArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5308)}, + {"UniformTexelBufferArrayDynamicIndexing", static_cast<SpvCapability>(5304)}, + {"GroupNonUniformArithmetic", static_cast<SpvCapability>(63)}, + {"RoundingModeRTZ", static_cast<SpvCapability>(4468)}, + {"StorageTexelBufferArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5312)}, + {"FPGADSPControlINTEL", static_cast<SpvCapability>(5908)}, + {"SubgroupAvcMotionEstimationINTEL", static_cast<SpvCapability>(5696)}, + {"LongConstantCompositeINTEL", static_cast<SpvCapability>(6089)}, + {"UniformAndStorageBuffer16BitAccess", static_cast<SpvCapability>(4434)}, + {"DotProductInputAll", static_cast<SpvCapability>(6016)}, + {"VulkanMemoryModel", static_cast<SpvCapability>(5345)}, + {"FPMaxErrorINTEL", static_cast<SpvCapability>(6169)}, + {"VariablePointersStorageBuffer", static_cast<SpvCapability>(4441)}, + {"ImageGatherExtended", static_cast<SpvCapability>(25)}, + {"ShaderLayer", static_cast<SpvCapability>(69)}, + {"FragmentShaderShadingRateInterlockEXT", static_cast<SpvCapability>(5372)}, + {"FPGAInvocationPipeliningAttributesINTEL", static_cast<SpvCapability>(5916)}, + {"GroupNonUniform", static_cast<SpvCapability>(61)}, + {"AtomicFloat16MinMaxEXT", static_cast<SpvCapability>(5616)}, + {"FragmentShaderPixelInterlockEXT", static_cast<SpvCapability>(5378)}, + {"AtomicStorage", static_cast<SpvCapability>(21)}, + {"RayQueryKHR", static_cast<SpvCapability>(4472)}, + {"TextureBoxFilterQCOM", static_cast<SpvCapability>(4485)}, + {"GroupNonUniformBallot", static_cast<SpvCapability>(64)}, + {"ShaderViewportMaskNV", static_cast<SpvCapability>(5255)}, + {"WorkgroupMemoryExplicitLayout16BitAccessKHR", static_cast<SpvCapability>(4430)}, + {"AtomicFloat32AddEXT", static_cast<SpvCapability>(6033)}, + {"LoopFuseINTEL", static_cast<SpvCapability>(5906)}, + {"DerivativeControl", static_cast<SpvCapability>(51)}, + {"FunctionFloatControlINTEL", static_cast<SpvCapability>(5821)}, + {"RayTracingMotionBlurNV", static_cast<SpvCapability>(5341)}, + {"FragmentMaskAMD", static_cast<SpvCapability>(5010)}, + {"Geometry", static_cast<SpvCapability>(2)}, + {"SubgroupAvcMotionEstimationChromaINTEL", static_cast<SpvCapability>(5698)}, + {"RayTraversalPrimitiveCullingKHR", static_cast<SpvCapability>(4478)}, + {"TessellationPointSize", static_cast<SpvCapability>(23)}, + {"Addresses", static_cast<SpvCapability>(4)}, + {"SubgroupDispatch", static_cast<SpvCapability>(58)}, + {"StorageBuffer16BitAccess", static_cast<SpvCapability>(4433)}, + {"StorageUniformBufferBlock16", static_cast<SpvCapability>(4433)}, + {"ImageQuery", static_cast<SpvCapability>(50)}, + {"InterpolationFunction", static_cast<SpvCapability>(52)}, + {"UnstructuredLoopControlsINTEL", static_cast<SpvCapability>(5886)}, + {"GeometryPointSize", static_cast<SpvCapability>(24)}, + {"InputAttachmentArrayDynamicIndexingEXT", static_cast<SpvCapability>(5303)}, + {"ShaderNonUniform", static_cast<SpvCapability>(5301)}, + {"StorageImageReadWithoutFormat", static_cast<SpvCapability>(55)}, + {"GroupNonUniformShuffle", static_cast<SpvCapability>(65)}, + {"WorkgroupMemoryExplicitLayout8BitAccessKHR", static_cast<SpvCapability>(4429)}, + {"GroupNonUniformQuad", static_cast<SpvCapability>(68)}, + {"Float16", static_cast<SpvCapability>(9)}, + {"ClipDistance", static_cast<SpvCapability>(32)}, + {"SignedZeroInfNanPreserve", static_cast<SpvCapability>(4466)}, + {"ImageReadWrite", static_cast<SpvCapability>(14)}, + {"Kernel", static_cast<SpvCapability>(6)}, + {"RayQueryPositionFetchKHR", static_cast<SpvCapability>(5391)}, + {"BindlessTextureNV", static_cast<SpvCapability>(5390)}, + {"ImageGatherBiasLodAMD", static_cast<SpvCapability>(5009)}, + {"StorageImageExtendedFormats", static_cast<SpvCapability>(49)}, + {"FPGARegINTEL", static_cast<SpvCapability>(5948)}, + {"Matrix", static_cast<SpvCapability>(0)}, + {"StorageImageMultisample", static_cast<SpvCapability>(27)}, + {"Float16Buffer", static_cast<SpvCapability>(8)}, + {"SampledCubeArray", static_cast<SpvCapability>(45)}, + {"DebugInfoModuleINTEL", static_cast<SpvCapability>(6114)}, + {"MinLod", static_cast<SpvCapability>(42)}, + {"RayQueryProvisionalKHR", static_cast<SpvCapability>(4471)}, + {"ExpectAssumeKHR", static_cast<SpvCapability>(5629)}, + {"Vector16", static_cast<SpvCapability>(7)}, + {"RuntimeDescriptorArrayEXT", static_cast<SpvCapability>(5302)}, + {"SubgroupAvcMotionEstimationIntraINTEL", static_cast<SpvCapability>(5697)}, + {"ImageReadWriteLodAMD", static_cast<SpvCapability>(5015)}, + {"ShaderNonUniformEXT", static_cast<SpvCapability>(5301)}, + {"SubgroupImageBlockIOINTEL", static_cast<SpvCapability>(5570)}, + {"FPGALatencyControlINTEL", static_cast<SpvCapability>(6171)}, + {"FPGAMemoryAttributesINTEL", static_cast<SpvCapability>(5824)}, + {"SampleMaskPostDepthCoverage", static_cast<SpvCapability>(4447)}, + {"InputAttachment", static_cast<SpvCapability>(40)}, + {"SampledBuffer", static_cast<SpvCapability>(46)}, + {"FPGAKernelAttributesINTEL", static_cast<SpvCapability>(5897)}, + {"CoreBuiltinsARM", static_cast<SpvCapability>(4165)}, + {"DotProductInput4x8BitPacked", static_cast<SpvCapability>(6018)}, + {"FragmentDensityEXT", static_cast<SpvCapability>(5291)}, + {"Int64ImageEXT", static_cast<SpvCapability>(5016)}, + {"MeshShadingNV", static_cast<SpvCapability>(5266)}, + {"StorageTexelBufferArrayNonUniformIndexing", static_cast<SpvCapability>(5312)}, + {"FloatingPointModeINTEL", static_cast<SpvCapability>(5583)}, + {"RayTracingNV", static_cast<SpvCapability>(5340)}, + {"VectorComputeINTEL", static_cast<SpvCapability>(5617)}, + {"CooperativeMatrixKHR", static_cast<SpvCapability>(6022)}, + {"FPGAMemoryAccessesINTEL", static_cast<SpvCapability>(5898)}, + {"RuntimeAlignedAttributeINTEL", static_cast<SpvCapability>(5939)}, + {"StorageBufferArrayDynamicIndexing", static_cast<SpvCapability>(30)}, + {"Int64", static_cast<SpvCapability>(11)}, + {"UniformAndStorageBuffer8BitAccess", static_cast<SpvCapability>(4449)}, + {"RuntimeDescriptorArray", static_cast<SpvCapability>(5302)}, + {"TileImageColorReadAccessEXT", static_cast<SpvCapability>(4166)}, + {"UniformTexelBufferArrayDynamicIndexingEXT", static_cast<SpvCapability>(5304)}, + {"BlockingPipesINTEL", static_cast<SpvCapability>(5945)}, + {"VariableLengthArrayINTEL", static_cast<SpvCapability>(5817)}, + {"SubgroupImageMediaBlockIOINTEL", static_cast<SpvCapability>(5579)}, + {"Tessellation", static_cast<SpvCapability>(3)}, + {"SampleMaskOverrideCoverageNV", static_cast<SpvCapability>(5249)}, + {"ImageBuffer", static_cast<SpvCapability>(47)}, + {"Linkage", static_cast<SpvCapability>(5)}, + {"USMStorageClassesINTEL", static_cast<SpvCapability>(5935)}, + {"ComputeDerivativeGroupLinearNV", static_cast<SpvCapability>(5350)}, + {"StorageImageArrayNonUniformIndexing", static_cast<SpvCapability>(5309)}, + {"StorageImageArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5309)}, + {"ImageRect", static_cast<SpvCapability>(36)}, + {"Float16ImageAMD", static_cast<SpvCapability>(5008)}, + {"SparseResidency", static_cast<SpvCapability>(41)}, + {"NamedBarrier", static_cast<SpvCapability>(59)}, + {"GenericPointer", static_cast<SpvCapability>(38)}, + {"SubgroupBufferBlockIOINTEL", static_cast<SpvCapability>(5569)}, + {"InputAttachmentArrayNonUniformIndexing", static_cast<SpvCapability>(5310)}, + {"TransformFeedback", static_cast<SpvCapability>(53)}, + {"AtomicFloat32MinMaxEXT", static_cast<SpvCapability>(5612)}, + {"StorageBufferArrayNonUniformIndexing", static_cast<SpvCapability>(5308)}, + {"CullDistance", static_cast<SpvCapability>(33)}, + {"OptNoneINTEL", static_cast<SpvCapability>(6094)}, + {"SampledImageArrayNonUniformIndexing", static_cast<SpvCapability>(5307)}, + {"SubgroupBallotKHR", static_cast<SpvCapability>(4423)}, + {"DrawParameters", static_cast<SpvCapability>(4427)}, + {"ShaderStereoViewNV", static_cast<SpvCapability>(5259)}, + {"ImageFootprintNV", static_cast<SpvCapability>(5282)}, + {"StorageBuffer8BitAccess", static_cast<SpvCapability>(4448)}, + {"UniformDecoration", static_cast<SpvCapability>(71)}, + {"ShaderViewportIndexLayerEXT", static_cast<SpvCapability>(5254)}, + {"BitInstructions", static_cast<SpvCapability>(6025)}, + {"GroupNonUniformRotateKHR", static_cast<SpvCapability>(6026)}, + {"PerViewAttributesNV", static_cast<SpvCapability>(5260)}, + {"Sampled1D", static_cast<SpvCapability>(43)}, + {"ArbitraryPrecisionFloatingPointINTEL", static_cast<SpvCapability>(5845)}, + {"VectorAnyINTEL", static_cast<SpvCapability>(5619)}, + {"PipeStorage", static_cast<SpvCapability>(60)}, + {"DemoteToHelperInvocation", static_cast<SpvCapability>(5379)}, + {"DenormFlushToZero", static_cast<SpvCapability>(4465)}, + {"Float64", static_cast<SpvCapability>(10)}, + {"VulkanMemoryModelDeviceScope", static_cast<SpvCapability>(5346)}, + {"IndirectReferencesINTEL", static_cast<SpvCapability>(5604)}, + {"DotProductKHR", static_cast<SpvCapability>(6019)}, + {"UniformBufferArrayDynamicIndexing", static_cast<SpvCapability>(28)}, + {"InputAttachmentArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5310)}, + {"LiteralSampler", static_cast<SpvCapability>(20)}, + {"SubgroupShuffleINTEL", static_cast<SpvCapability>(5568)}, + {"InputAttachmentArrayDynamicIndexing", static_cast<SpvCapability>(5303)}, + {"GeometryShaderPassthroughNV", static_cast<SpvCapability>(5251)}, + {"Int16", static_cast<SpvCapability>(22)}, + {"StoragePushConstant16", static_cast<SpvCapability>(4435)}, + {"GeometryStreams", static_cast<SpvCapability>(54)}, + {"VulkanMemoryModelDeviceScopeKHR", static_cast<SpvCapability>(5346)}, + {"ShaderInvocationReorderNV", static_cast<SpvCapability>(5383)}, + {"FPGABufferLocationINTEL", static_cast<SpvCapability>(5920)}, + {"WorkgroupMemoryExplicitLayoutKHR", static_cast<SpvCapability>(4428)}, + {"GroupNonUniformClustered", static_cast<SpvCapability>(67)}, + {"FunctionPointersINTEL", static_cast<SpvCapability>(5603)}, + {"Image1D", static_cast<SpvCapability>(44)}, + {"DotProductInputAllKHR", static_cast<SpvCapability>(6016)}, + {"BFloat16ConversionINTEL", static_cast<SpvCapability>(6115)}, + {"ImageMipmap", static_cast<SpvCapability>(15)}, + {"KernelAttributesINTEL", static_cast<SpvCapability>(5892)}, + {"TextureSampleWeightedQCOM", static_cast<SpvCapability>(4484)}, + {"IOPipesINTEL", static_cast<SpvCapability>(5943)}, + {"MultiView", static_cast<SpvCapability>(4439)}, + {"RayTracingPositionFetchKHR", static_cast<SpvCapability>(5336)}, + {"StorageTexelBufferArrayDynamicIndexing", static_cast<SpvCapability>(5305)}, + {"UniformTexelBufferArrayNonUniformIndexingEXT", static_cast<SpvCapability>(5311)}, + {"AtomicFloat64MinMaxEXT", static_cast<SpvCapability>(5613)}, + {"StencilExportEXT", static_cast<SpvCapability>(5013)}, + {"RayTracingKHR", static_cast<SpvCapability>(4479)}, + {"DenormPreserve", static_cast<SpvCapability>(4464)}, + {"RayTracingOpacityMicromapEXT", static_cast<SpvCapability>(5381)}, + {"ArbitraryPrecisionIntegersINTEL", static_cast<SpvCapability>(5844)}, + {"TileImageDepthReadAccessEXT", static_cast<SpvCapability>(4167)}, + {"SplitBarrierINTEL", static_cast<SpvCapability>(6141)}, + {"RayCullMaskKHR", static_cast<SpvCapability>(6020)}, + {"ImageCubeArray", static_cast<SpvCapability>(34)}, + {"FragmentBarycentricNV", static_cast<SpvCapability>(5284)}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 245; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool lookupEnumWithTypePrefix(const UnownedStringSlice& str, SpvWord& value) +{ + static const unsigned tableSalt[944] = { + 0, 2, 0, 4, 3, 1, 1, 3, 0, 2, 1, 3, 1, 0, 0, 2, + 0, 1, 1, 7, 0, 0, 1, 0, 2, 0, 0, 0, 3, 1, 1, 0, + 12, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 2, 1, + 0, 5, 0, 3, 5, 4, 1, 0, 0, 8, 3, 0, 1, 0, 1, 8, + 0, 9, 0, 0, 11, 3, 2, 0, 6, 0, 2, 3, 0, 5, 0, 0, + 0, 1, 1, 0, 1, 0, 0, 4, 1, 1, 0, 0, 0, 1, 0, 2, + 6, 0, 0, 0, 1, 6, 2, 1, 1, 0, 0, 5, 0, 1, 3, 1, + 0, 2, 0, 1, 1, 3, 1, 5, 0, 5, 1, 2, 1, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 6, 3, 1, 2, 3, 6, 4, 0, 2, 0, + 1, 1, 2, 4, 4, 0, 1, 0, 1, 1, 1, 0, 0, 0, 4, 1, + 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 9, 0, 1, + 2, 1, 0, 2, 3, 0, 0, 0, 1, 3, 1, 5, 0, 6, 3, 0, + 7, 2, 0, 0, 1, 2, 0, 3, 1, 5, 2, 1, 1, 5, 1, 0, + 1, 0, 4, 0, 3, 8, 0, 6, 0, 0, 0, 2, 3, 3, 7, 1, + 1, 0, 1, 2, 0, 1, 0, 4, 0, 1, 4, 2, 0, 0, 2, 0, + 0, 0, 14, 1, 0, 2, 1, 0, 1, 1, 3, 0, 0, 0, 1, 0, + 3, 0, 4, 1, 0, 0, 1, 0, 0, 0, 4, 6, 1, 0, 0, 0, + 1, 3, 5, 6, 2, 3, 0, 6, 6, 1, 1, 0, 0, 2, 0, 1, + 0, 1, 1, 9, 2, 2, 4, 3, 2, 0, 2, 0, 5, 9, 1, 2, + 1, 2, 2, 0, 1, 1, 0, 0, 3, 2, 0, 0, 1, 1, 0, 3, + 3, 1, 10, 0, 0, 4, 0, 0, 2, 0, 0, 4, 2, 3, 2, 4, + 1, 0, 3, 1, 0, 3, 1, 3, 1, 3, 0, 0, 2, 0, 1, 0, + 0, 1, 0, 2, 2, 0, 0, 7, 1, 1, 8, 0, 1, 6, 0, 2, + 2, 3, 2, 1, 1, 0, 0, 3, 1, 1, 0, 0, 0, 2, 2, 1, + 0, 0, 3, 1, 1, 1, 3, 3, 0, 1, 2, 0, 1, 3, 5, 0, + 0, 2, 2, 1, 8, 1, 12, 0, 2, 2, 17, 4, 0, 1, 1, 1, + 11, 3, 1, 2, 4, 5, 1, 0, 4, 3, 3, 1, 1, 2, 1, 5, + 3, 1, 3, 1, 5, 2, 2, 0, 5, 0, 1, 0, 1, 3, 1, 2, + 2, 0, 0, 2, 5, 0, 0, 2, 8, 2, 8, 0, 3, 1, 0, 4, + 0, 0, 1, 3, 1, 2, 0, 2, 2, 13, 0, 4, 0, 3, 3, 0, + 2, 5, 1, 3, 5, 7, 2, 7, 1, 0, 13, 0, 3, 2, 1, 22, + 0, 3, 2, 4, 0, 1, 2, 5, 0, 2, 0, 2, 0, 5, 0, 0, + 0, 0, 1, 17, 0, 1, 11, 0, 5, 2, 0, 0, 4, 1, 17, 0, + 0, 0, 1, 2, 5, 0, 0, 1, 1, 1, 26, 1, 5, 0, 1, 0, + 1, 2, 0, 5, 5, 12, 1, 11, 17, 1, 2, 5, 0, 3, 11, 0, + 5, 1, 5, 5, 3, 0, 0, 3, 1, 0, 4, 1, 8, 1, 8, 0, + 0, 22, 1, 0, 3, 8, 1, 9, 4, 1, 0, 10, 0, 12, 1, 0, + 11, 0, 0, 3, 42, 4, 0, 2, 0, 1, 4, 0, 11, 1, 4, 8, + 14, 3, 0, 1, 6, 17, 1, 2, 15, 0, 10, 1, 0, 14, 2, 12, + 0, 2, 0, 1, 6, 0, 13, 2, 1, 0, 7, 0, 6, 7, 0, 0, + 14, 1, 7, 3, 2, 0, 1, 0, 7, 0, 1, 2, 0, 22, 0, 6, + 0, 12, 3, 3, 4, 0, 10, 0, 0, 0, 2, 0, 4, 0, 0, 26, + 1, 1, 0, 9, 0, 9, 10, 4, 3, 0, 4, 0, 20, 0, 0, 3, + 10, 4, 14, 13, 10, 0, 15, 1, 0, 21, 1, 0, 22, 2, 3, 0, + 0, 0, 10, 17, 0, 3, 1, 1, 0, 0, 1, 11, 4, 0, 2, 3, + 0, 7, 23, 6, 0, 17, 0, 18, 0, 20, 2, 0, 0, 0, 4, 1, + 0, 0, 1, 0, 0, 4, 5, 0, 4, 1, 7, 0, 3, 3, 1, 5, + 3, 10, 11, 0, 16, 1, 0, 8, 6, 4, 0, 7, 0, 33, 1, 0, + 1, 18, 0, 0, 16, 6, 14, 34, 10, 28, 0, 0, 1, 1, 0, 7, + 4, 0, 2, 1, 1, 5, 0, 0, 2, 0, 31, 41, 0, 9, 10, 0, + 0, 0, 9, 0, 0, 12, 9, 0, 0, 0, 19, 4, 0, 4, 0, 10, + 0, 0, 21, 13, 0, 6, 1, 19, 0, 7, 6, 0, 0, 1, 4, 3, + 0, 16, 0, 8, 32, 8, 0, 9, 0, 9, 10, 0, 2, 0, 10, 20, + 45, 5, 2, 2, 0, 5, 2, 0, 31, 1, 1, 73, 30, 64, 19, 8, + 2, 108, 7, 16, 5, 15, 4, 1, 20, 36, 1, 44, 0, 3, 3, 8, + 0, 0, 0, 10, 32, 30, 0, 41, 0, 0, 29, 3, 0, 0, 15, 100, + 0, 4, 1, 29, 11, 64, 105, 125, 0, 0, 0, 38, 115, 1, 1, 1, + 0, 11, 21, 66, 1, 79, 4, 0, 0, 141, 1, 0, 0, 0, 0, 0, + 530, 0, 8, 31, 3, 1, 0, 13, 0, 0, 6, 286, 14, 16, 134, 259 + }; + + using KV = std::pair<const char*, SpvWord>; + + static const KV words[944] = + { + {"MemoryAccessMakePointerVisibleKHR", SpvWord{16}}, + {"CapabilityStoragePushConstant16", SpvWord{4435}}, + {"StorageClassTaskPayloadWorkgroupEXT", SpvWord{5402}}, + {"DecorationConduitKernelArgumentINTEL", SpvWord{6175}}, + {"BuiltInRayTminNV", SpvWord{5325}}, + {"MemoryAccessAligned", SpvWord{2}}, + {"ImageOperandsGrad", SpvWord{4}}, + {"CapabilityAtomicFloat32AddEXT", SpvWord{6033}}, + {"BuiltInWorldRayDirectionNV", SpvWord{5322}}, + {"SourceLanguageSYCL", SpvWord{7}}, + {"CapabilityFPGAInvocationPipeliningAttributesINTEL", SpvWord{5916}}, + {"BuiltInFragStencilRefEXT", SpvWord{5014}}, + {"FunctionControlNone", SpvWord{0}}, + {"BuiltInBaryCoordNoPerspNV", SpvWord{5287}}, + {"DecorationUniformId", SpvWord{27}}, + {"BuiltInGlobalLinearId", SpvWord{34}}, + {"DecorationLocation", SpvWord{30}}, + {"ImageFormatR16Snorm", SpvWord{19}}, + {"BuiltInSecondaryPositionNV", SpvWord{5257}}, + {"MemorySemanticsMakeAvailableKHR", SpvWord{8192}}, + {"ImageOperandsMinLod", SpvWord{128}}, + {"Dim1D", SpvWord{0}}, + {"SamplerAddressingModeRepeat", SpvWord{3}}, + {"CapabilityCooperativeMatrixKHR", SpvWord{6022}}, + {"ImageChannelDataTypeSignedInt8", SpvWord{7}}, + {"ImageOperandsNontemporal", SpvWord{16384}}, + {"BuiltInFragSizeEXT", SpvWord{5292}}, + {"FPFastMathModeNSZ", SpvWord{4}}, + {"ExecutionModeStencilRefGreaterFrontAMD", SpvWord{5080}}, + {"DecorationBuiltIn", SpvWord{11}}, + {"ExecutionModeOutputVertices", SpvWord{26}}, + {"DecorationDoublepumpINTEL", SpvWord{5831}}, + {"KernelEnqueueFlagsNoWait", SpvWord{0}}, + {"BuiltInBaryCoordNoPerspCentroidAMD", SpvWord{4993}}, + {"SourceLanguageUnknown", SpvWord{0}}, + {"FragmentShadingRateHorizontal4Pixels", SpvWord{8}}, + {"DecorationGLSLShared", SpvWord{8}}, + {"BuiltInFragCoord", SpvWord{15}}, + {"ImageChannelOrderRGB", SpvWord{4}}, + {"ImageFormatRgb10A2", SpvWord{11}}, + {"FPFastMathModeAllowContractFastINTEL", SpvWord{65536}}, + {"BuiltInTessCoord", SpvWord{13}}, + {"BuiltInLocalInvocationIndex", SpvWord{29}}, + {"ExecutionModeFloatingPointModeIEEEINTEL", SpvWord{5623}}, + {"ImageChannelOrderBGRA", SpvWord{6}}, + {"CapabilityRayCullMaskKHR", SpvWord{6020}}, + {"CapabilityVulkanMemoryModel", SpvWord{5345}}, + {"BuiltInWarpIDARM", SpvWord{4163}}, + {"BuiltInPrimitivePointIndicesEXT", SpvWord{5294}}, + {"ExecutionModeInvocations", SpvWord{0}}, + {"ImageOperandsConstOffset", SpvWord{8}}, + {"ImageFormatRg32f", SpvWord{6}}, + {"CapabilityInputAttachment", SpvWord{40}}, + {"RayFlagsCullNoOpaqueKHR", SpvWord{128}}, + {"CapabilityStorageImageArrayNonUniformIndexing", SpvWord{5309}}, + {"CapabilityIOPipesINTEL", SpvWord{5943}}, + {"ExecutionModeLocalSizeId", SpvWord{38}}, + {"PackedVectorFormatPackedVectorFormat4x8Bit", SpvWord{0}}, + {"AddressingModelPhysical32", SpvWord{1}}, + {"MemoryAccessNone", SpvWord{0}}, + {"ImageFormatRg32i", SpvWord{25}}, + {"BuiltInObjectToWorldKHR", SpvWord{5330}}, + {"DecorationCPacked", SpvWord{10}}, + {"DecorationConstant", SpvWord{22}}, + {"BuiltInVertexId", SpvWord{5}}, + {"ExecutionModelMeshEXT", SpvWord{5365}}, + {"DecorationFuseLoopsInFunctionINTEL", SpvWord{5907}}, + {"CapabilityInt16", SpvWord{22}}, + {"CapabilityFragmentDensityEXT", SpvWord{5291}}, + {"CapabilityGroupNonUniformBallot", SpvWord{64}}, + {"DecorationOffset", SpvWord{35}}, + {"StorageClassHostOnlyINTEL", SpvWord{5937}}, + {"DecorationMediaBlockIOINTEL", SpvWord{6140}}, + {"PackedVectorFormatPackedVectorFormat4x8BitKHR", SpvWord{0}}, + {"MemoryAccessNontemporal", SpvWord{4}}, + {"ExecutionModelRayGenerationKHR", SpvWord{5313}}, + {"DecorationUserSemantic", SpvWord{5635}}, + {"BuiltInFrontFacing", SpvWord{17}}, + {"RayFlagsNoneKHR", SpvWord{0}}, + {"ImageFormatRgba16", SpvWord{10}}, + {"BuiltInCurrentRayTimeNV", SpvWord{5334}}, + {"ExecutionModelCallableNV", SpvWord{5318}}, + {"MemoryModelVulkan", SpvWord{3}}, + {"ExecutionModeInputLines", SpvWord{20}}, + {"CapabilityShaderNonUniformEXT", SpvWord{5301}}, + {"BuiltInFullyCoveredEXT", SpvWord{5264}}, + {"DecorationFlat", SpvWord{14}}, + {"CapabilityImage1D", SpvWord{44}}, + {"StorageClassRayPayloadNV", SpvWord{5338}}, + {"SourceLanguageHERO_C", SpvWord{8}}, + {"CapabilityRuntimeDescriptorArrayEXT", SpvWord{5302}}, + {"CapabilityRayTracingPositionFetchKHR", SpvWord{5336}}, + {"BuiltInObjectRayOriginKHR", SpvWord{5323}}, + {"BuiltInViewportMaskNV", SpvWord{5253}}, + {"DecorationStallEnableINTEL", SpvWord{5905}}, + {"FunctionParameterAttributeZext", SpvWord{0}}, + {"ExecutionModeFloatingPointModeALTINTEL", SpvWord{5622}}, + {"DecorationMaxPrivateCopiesINTEL", SpvWord{5829}}, + {"BuiltInFragmentSizeNV", SpvWord{5292}}, + {"RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR", SpvWord{0}}, + {"DecorationNonUniform", SpvWord{5300}}, + {"CapabilitySampledCubeArray", SpvWord{45}}, + {"DimSubpassData", SpvWord{6}}, + {"CapabilitySignedZeroInfNanPreserve", SpvWord{4466}}, + {"BuiltInPrimitiveIndicesNV", SpvWord{5276}}, + {"ExecutionModeOutputPrimitivesNV", SpvWord{5270}}, + {"CapabilityTileImageStencilReadAccessEXT", SpvWord{4168}}, + {"FPRoundingModeRTZ", SpvWord{1}}, + {"ImageFormatRg8", SpvWord{13}}, + {"CapabilityStorageImageArrayDynamicIndexing", SpvWord{31}}, + {"FPOperationModeALT", SpvWord{1}}, + {"ExecutionModeOutputTrianglesEXT", SpvWord{5298}}, + {"RayFlagsNoOpaqueKHR", SpvWord{2}}, + {"ExecutionModelCallableKHR", SpvWord{5318}}, + {"RayFlagsCullFrontFacingTrianglesKHR", SpvWord{32}}, + {"CapabilityDenormPreserve", SpvWord{4464}}, + {"GroupOperationPartitionedExclusiveScanNV", SpvWord{8}}, + {"CapabilityFragmentBarycentricNV", SpvWord{5284}}, + {"FragmentShadingRateVertical2Pixels", SpvWord{1}}, + {"CapabilitySubgroupAvcMotionEstimationChromaINTEL", SpvWord{5698}}, + {"CapabilityImageBasic", SpvWord{13}}, + {"DecorationIOPipeStorageINTEL", SpvWord{5944}}, + {"StorageClassIncomingRayPayloadKHR", SpvWord{5342}}, + {"CapabilityPipeStorage", SpvWord{60}}, + {"CapabilityStorageBufferArrayNonUniformIndexingEXT", SpvWord{5308}}, + {"ExecutionModeOutputPoints", SpvWord{27}}, + {"DecorationBlock", SpvWord{2}}, + {"ExecutionModeSampleInterlockOrderedEXT", SpvWord{5368}}, + {"DecorationRestrictPointerEXT", SpvWord{5355}}, + {"MemorySemanticsSubgroupMemory", SpvWord{128}}, + {"CapabilityShaderViewportIndexLayerEXT", SpvWord{5254}}, + {"CapabilityMeshShadingNV", SpvWord{5266}}, + {"ExecutionModeVertexOrderCw", SpvWord{4}}, + {"ExecutionModeEarlyFragmentTests", SpvWord{9}}, + {"BuiltInHitTriangleVertexPositionsKHR", SpvWord{5335}}, + {"CapabilityBlockingPipesINTEL", SpvWord{5945}}, + {"ImageChannelOrderR", SpvWord{0}}, + {"ExecutionModeOutputTrianglesNV", SpvWord{5298}}, + {"CapabilityClipDistance", SpvWord{32}}, + {"MemorySemanticsNone", SpvWord{0}}, + {"CapabilityUniformBufferArrayNonUniformIndexingEXT", SpvWord{5306}}, + {"ExecutionModeInputLinesAdjacency", SpvWord{21}}, + {"ExecutionModelMissNV", SpvWord{5317}}, + {"BuiltInSubgroupEqMask", SpvWord{4416}}, + {"FunctionParameterAttributeRuntimeAlignedINTEL", SpvWord{5940}}, + {"CapabilityFPGAMemoryAttributesINTEL", SpvWord{5824}}, + {"ImageChannelOrderRG", SpvWord{2}}, + {"RayFlagsCullBackFacingTrianglesKHR", SpvWord{16}}, + {"BuiltInObjectRayDirectionNV", SpvWord{5324}}, + {"CapabilityCoreBuiltinsARM", SpvWord{4165}}, + {"CapabilityFPGADSPControlINTEL", SpvWord{5908}}, + {"BuiltInNumEnqueuedSubgroups", SpvWord{39}}, + {"DecorationArrayStride", SpvWord{6}}, + {"CapabilityInt64Atomics", SpvWord{12}}, + {"MemoryModelSimple", SpvWord{0}}, + {"ImageFormatRgba16i", SpvWord{22}}, + {"CapabilityDotProductInput4x8BitPackedKHR", SpvWord{6018}}, + {"ExecutionModeEarlyAndLateFragmentTestsAMD", SpvWord{5017}}, + {"BuiltInLayer", SpvWord{9}}, + {"BuiltInBaryCoordSmoothAMD", SpvWord{4995}}, + {"ExecutionModeInitializer", SpvWord{33}}, + {"ImageChannelDataTypeUnormShort555", SpvWord{5}}, + {"FPOperationModeIEEE", SpvWord{0}}, + {"MemoryAccessNonPrivatePointer", SpvWord{32}}, + {"BuiltInLaunchIdNV", SpvWord{5319}}, + {"CapabilityGroupNonUniformArithmetic", SpvWord{63}}, + {"ExecutionModelTessellationControl", SpvWord{1}}, + {"ImageFormatRg16Snorm", SpvWord{17}}, + {"LoopControlMaxIterations", SpvWord{32}}, + {"CapabilityTessellationPointSize", SpvWord{23}}, + {"ExecutionModeNonCoherentDepthAttachmentReadEXT", SpvWord{4170}}, + {"ImageChannelOrderDepthStencil", SpvWord{14}}, + {"ImageOperandsNonPrivateTexelKHR", SpvWord{1024}}, + {"DimRect", SpvWord{4}}, + {"QuantizationModesTRN_ZERO", SpvWord{1}}, + {"CapabilitySampleRateShading", SpvWord{35}}, + {"GroupOperationExclusiveScan", SpvWord{2}}, + {"DecorationCounterBuffer", SpvWord{5634}}, + {"GroupOperationInclusiveScan", SpvWord{1}}, + {"BuiltInLayerPerViewNV", SpvWord{5279}}, + {"ExecutionModeSampleInterlockUnorderedEXT", SpvWord{5369}}, + {"OverflowModesWRAP", SpvWord{0}}, + {"ExecutionModeDerivativeGroupQuadsNV", SpvWord{5289}}, + {"BuiltInHitKindNV", SpvWord{5333}}, + {"BuiltInClipDistance", SpvWord{3}}, + {"ExecutionModeDepthReplacing", SpvWord{12}}, + {"CapabilityPerViewAttributesNV", SpvWord{5260}}, + {"DecorationUserTypeGOOGLE", SpvWord{5636}}, + {"ExecutionModePixelInterlockOrderedEXT", SpvWord{5366}}, + {"CapabilitySampledBuffer", SpvWord{46}}, + {"DecorationBinding", SpvWord{33}}, + {"BuiltInHitTNV", SpvWord{5332}}, + {"CapabilityUnstructuredLoopControlsINTEL", SpvWord{5886}}, + {"ExecutionModeSpacingFractionalOdd", SpvWord{3}}, + {"SourceLanguageCPP_for_OpenCL", SpvWord{6}}, + {"ExecutionModeShadingRateInterlockUnorderedEXT", SpvWord{5371}}, + {"RayFlagsSkipAABBsKHR", SpvWord{512}}, + {"ImageChannelDataTypeSignedInt16", SpvWord{8}}, + {"CapabilityOptNoneINTEL", SpvWord{6094}}, + {"DecorationCoherent", SpvWord{23}}, + {"ExecutionModelMissKHR", SpvWord{5317}}, + {"BuiltInInstanceIndex", SpvWord{43}}, + {"ImageFormatR8", SpvWord{15}}, + {"SourceLanguageHLSL", SpvWord{5}}, + {"CapabilityGroups", SpvWord{18}}, + {"CapabilitySampledImageArrayNonUniformIndexingEXT", SpvWord{5307}}, + {"CapabilityDemoteToHelperInvocationEXT", SpvWord{5379}}, + {"CapabilityStorageTexelBufferArrayDynamicIndexingEXT", SpvWord{5305}}, + {"ImageChannelDataTypeUnormInt8", SpvWord{2}}, + {"CapabilityImageFootprintNV", SpvWord{5282}}, + {"ExecutionModeNamedBarrierCountINTEL", SpvWord{6417}}, + {"StorageClassCallableDataNV", SpvWord{5328}}, + {"CapabilityImageCubeArray", SpvWord{34}}, + {"BuiltInBaryCoordSmoothSampleAMD", SpvWord{4997}}, + {"ImageOperandsMakeTexelVisibleKHR", SpvWord{512}}, + {"DecorationPerViewNV", SpvWord{5272}}, + {"OverflowModesSAT_SYM", SpvWord{3}}, + {"CapabilityAddresses", SpvWord{4}}, + {"CapabilityFPGABufferLocationINTEL", SpvWord{5920}}, + {"CapabilityFunctionPointersINTEL", SpvWord{5603}}, + {"CapabilityMatrix", SpvWord{0}}, + {"CooperativeMatrixOperandsSaturatingAccumulationKHR", SpvWord{16}}, + {"ImageChannelOrderRGx", SpvWord{11}}, + {"BuiltInCullDistance", SpvWord{4}}, + {"DecorationFPFastMathMode", SpvWord{40}}, + {"MemorySemanticsOutputMemory", SpvWord{4096}}, + {"CapabilitySampleMaskOverrideCoverageNV", SpvWord{5249}}, + {"CapabilityUniformAndStorageBuffer16BitAccess", SpvWord{4434}}, + {"MemoryAccessMakePointerAvailable", SpvWord{8}}, + {"DecorationVectorComputeVariableINTEL", SpvWord{5624}}, + {"BuiltInObjectRayDirectionKHR", SpvWord{5324}}, + {"DecorationFunctionDenormModeINTEL", SpvWord{5823}}, + {"DecorationAliased", SpvWord{20}}, + {"CapabilityCullDistance", SpvWord{33}}, + {"CapabilityIndirectReferencesINTEL", SpvWord{5604}}, + {"DecorationBoundSamplerNV", SpvWord{5400}}, + {"BuiltInNumWorkgroups", SpvWord{24}}, + {"BuiltInFragDepth", SpvWord{22}}, + {"CapabilityGroupNonUniform", SpvWord{61}}, + {"BuiltInSubgroupLeMaskKHR", SpvWord{4419}}, + {"BuiltInTessLevelOuter", SpvWord{11}}, + {"ExecutionModeVecTypeHint", SpvWord{30}}, + {"ExecutionModePixelCenterInteger", SpvWord{6}}, + {"BuiltInLaunchIdKHR", SpvWord{5319}}, + {"QuantizationModesRND_CONV", SpvWord{6}}, + {"StorageClassStorageBuffer", SpvWord{12}}, + {"CapabilityLongConstantCompositeINTEL", SpvWord{6089}}, + {"MemorySemanticsSequentiallyConsistent", SpvWord{16}}, + {"DecorationInvariant", SpvWord{18}}, + {"ExecutionModeDepthGreater", SpvWord{14}}, + {"ImageFormatRg16ui", SpvWord{36}}, + {"ImageChannelOrdersRGB", SpvWord{15}}, + {"BuiltInMeshViewCountNV", SpvWord{5280}}, + {"MemoryAccessVolatile", SpvWord{1}}, + {"CapabilityShaderViewportIndex", SpvWord{70}}, + {"ExecutionModeInputTrianglesAdjacency", SpvWord{23}}, + {"ImageFormatR11fG11fB10f", SpvWord{8}}, + {"ImageOperandsSignExtend", SpvWord{4096}}, + {"CapabilityDotProductInputAll", SpvWord{6016}}, + {"CapabilityDeviceGroup", SpvWord{4437}}, + {"MemorySemanticsMakeAvailable", SpvWord{8192}}, + {"ExecutionModeSpacingEqual", SpvWord{1}}, + {"ExecutionModeStencilRefGreaterBackAMD", SpvWord{5083}}, + {"LoopControlMaxConcurrencyINTEL", SpvWord{131072}}, + {"DecorationDontStaticallyCoalesceINTEL", SpvWord{5901}}, + {"DecorationMaxReplicatesINTEL", SpvWord{5832}}, + {"CapabilityUniformDecoration", SpvWord{71}}, + {"LoopControlSpeculatedIterationsINTEL", SpvWord{4194304}}, + {"CapabilityImageGatherExtended", SpvWord{25}}, + {"ImageChannelOrderLuminance", SpvWord{9}}, + {"DecorationMaxConcurrencyINTEL", SpvWord{5918}}, + {"ExecutionModeOutputPrimitivesEXT", SpvWord{5270}}, + {"ImageFormatR8Snorm", SpvWord{20}}, + {"CapabilitySampleMaskPostDepthCoverage", SpvWord{4447}}, + {"MemorySemanticsAtomicCounterMemory", SpvWord{1024}}, + {"CapabilityExpectAssumeKHR", SpvWord{5629}}, + {"BuiltInInvocationsPerPixelNV", SpvWord{5293}}, + {"CapabilityAtomicStorageOps", SpvWord{4445}}, + {"DecorationAlignmentId", SpvWord{46}}, + {"ExecutionModelMeshNV", SpvWord{5268}}, + {"BuiltInSubgroupGtMask", SpvWord{4418}}, + {"DecorationSpecId", SpvWord{1}}, + {"CapabilityBFloat16ConversionINTEL", SpvWord{6115}}, + {"BuiltInWarpsPerSMNV", SpvWord{5374}}, + {"StorageClassAtomicCounter", SpvWord{10}}, + {"DecorationPipelineEnableINTEL", SpvWord{5919}}, + {"RayFlagsOpaqueKHR", SpvWord{1}}, + {"CapabilitySubgroupBufferBlockIOINTEL", SpvWord{5569}}, + {"ExecutionModelGLCompute", SpvWord{5}}, + {"DecorationFuncParamAttr", SpvWord{38}}, + {"StorageClassIncomingRayPayloadNV", SpvWord{5342}}, + {"ExecutionModeSubgroupSize", SpvWord{35}}, + {"DecorationNoPerspective", SpvWord{13}}, + {"DecorationBoundImageNV", SpvWord{5401}}, + {"CapabilityStorageImageReadWithoutFormat", SpvWord{55}}, + {"BuiltInRayGeometryIndexKHR", SpvWord{5352}}, + {"BuiltInShadingRateKHR", SpvWord{4444}}, + {"QuantizationModesTRN", SpvWord{0}}, + {"CapabilityShaderViewportMaskNV", SpvWord{5255}}, + {"BuiltInCullDistancePerViewNV", SpvWord{5278}}, + {"ExecutionModelTessellationEvaluation", SpvWord{2}}, + {"ImageOperandsVolatileTexelKHR", SpvWord{2048}}, + {"CapabilityGroupNonUniformShuffleRelative", SpvWord{66}}, + {"DecorationRestrict", SpvWord{19}}, + {"ExecutionModelGeometry", SpvWord{3}}, + {"CapabilitySubgroupVoteKHR", SpvWord{4431}}, + {"CapabilityStencilExportEXT", SpvWord{5013}}, + {"DecorationPerVertexKHR", SpvWord{5285}}, + {"StorageClassHitAttributeNV", SpvWord{5339}}, + {"CapabilityFragmentShaderShadingRateInterlockEXT", SpvWord{5372}}, + {"Dim3D", SpvWord{2}}, + {"CapabilitySampledImageArrayNonUniformIndexing", SpvWord{5307}}, + {"StorageClassIncomingCallableDataKHR", SpvWord{5329}}, + {"CapabilityTextureBoxFilterQCOM", SpvWord{4485}}, + {"CooperativeMatrixOperandsMatrixBSignedComponentsKHR", SpvWord{2}}, + {"CapabilityInputAttachmentArrayNonUniformIndexing", SpvWord{5310}}, + {"ImageFormatR64i", SpvWord{41}}, + {"CapabilityFPGAClusterAttributesINTEL", SpvWord{5904}}, + {"KernelEnqueueFlagsWaitWorkGroup", SpvWord{2}}, + {"DecorationHlslSemanticGOOGLE", SpvWord{5635}}, + {"ExecutionModeTriangles", SpvWord{22}}, + {"SamplerAddressingModeNone", SpvWord{0}}, + {"LoopControlMaxInterleavingINTEL", SpvWord{2097152}}, + {"CapabilityVectorComputeINTEL", SpvWord{5617}}, + {"DecorationBufferLocationINTEL", SpvWord{5921}}, + {"CapabilityShaderViewportIndexLayerNV", SpvWord{5254}}, + {"RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR", SpvWord{0}}, + {"BuiltInLaunchSizeKHR", SpvWord{5320}}, + {"BuiltInIncomingRayFlagsKHR", SpvWord{5351}}, + {"CooperativeMatrixLayoutRowMajorKHR", SpvWord{0}}, + {"StorageClassPhysicalStorageBuffer", SpvWord{5349}}, + {"DecorationMatrixStride", SpvWord{7}}, + {"ImageFormatRgba16Snorm", SpvWord{16}}, + {"DecorationCacheSizeINTEL", SpvWord{5900}}, + {"BuiltInWorldToObjectKHR", SpvWord{5331}}, + {"AccessQualifierWriteOnly", SpvWord{1}}, + {"DecorationNonReadable", SpvWord{25}}, + {"CapabilityRoundToInfinityINTEL", SpvWord{5582}}, + {"ImageFormatRgba32f", SpvWord{1}}, + {"CapabilityFPMaxErrorINTEL", SpvWord{6169}}, + {"ImageChannelOrderRGBx", SpvWord{12}}, + {"CapabilitySparseResidency", SpvWord{41}}, + {"DecorationMaxByteOffset", SpvWord{45}}, + {"CapabilityStorageUniform16", SpvWord{4434}}, + {"CapabilityStorageImageMultisample", SpvWord{27}}, + {"DecorationBurstCoalesceINTEL", SpvWord{5899}}, + {"BuiltInBaryCoordNoPerspAMD", SpvWord{4992}}, + {"ImageOperandsOffsets", SpvWord{65536}}, + {"LoopControlDependencyArrayINTEL", SpvWord{262144}}, + {"CapabilityShadingRateNV", SpvWord{5291}}, + {"LoopControlPipelineEnableINTEL", SpvWord{524288}}, + {"CapabilityFragmentMaskAMD", SpvWord{5010}}, + {"BuiltInCoreMaxIDARM", SpvWord{4162}}, + {"CapabilityImageGatherBiasLodAMD", SpvWord{5009}}, + {"CapabilityRuntimeAlignedAttributeINTEL", SpvWord{5939}}, + {"AddressingModelLogical", SpvWord{0}}, + {"BuiltInHelperInvocation", SpvWord{23}}, + {"ScopeShaderCallKHR", SpvWord{6}}, + {"CapabilityVariableLengthArrayINTEL", SpvWord{5817}}, + {"ExecutionModeRegisterMapInterfaceINTEL", SpvWord{6160}}, + {"DecorationRegisterINTEL", SpvWord{5825}}, + {"CooperativeMatrixLayoutColumnMajorKHR", SpvWord{1}}, + {"DecorationInitiationIntervalINTEL", SpvWord{5917}}, + {"CapabilitySubgroupBallotKHR", SpvWord{4423}}, + {"MemoryAccessMakePointerVisible", SpvWord{16}}, + {"ImageChannelOrderA", SpvWord{1}}, + {"CapabilityFPGAArgumentInterfacesINTEL", SpvWord{6174}}, + {"DecorationBufferBlock", SpvWord{3}}, + {"CapabilityDerivativeControl", SpvWord{51}}, + {"FPFastMathModeFast", SpvWord{16}}, + {"SamplerFilterModeNearest", SpvWord{0}}, + {"CapabilityVulkanMemoryModelKHR", SpvWord{5345}}, + {"ImageChannelDataTypeHalfFloat", SpvWord{13}}, + {"BuiltInSampleMask", SpvWord{20}}, + {"CapabilityTextureSampleWeightedQCOM", SpvWord{4484}}, + {"DecorationReferencedIndirectlyINTEL", SpvWord{5602}}, + {"ExecutionModeStencilRefLessFrontAMD", SpvWord{5081}}, + {"DecorationBankwidthINTEL", SpvWord{5828}}, + {"ImageChannelDataTypeSignedInt32", SpvWord{9}}, + {"StorageClassShaderRecordBufferKHR", SpvWord{5343}}, + {"ExecutionModeInputPoints", SpvWord{19}}, + {"CapabilityImageMipmap", SpvWord{15}}, + {"CapabilityVariablePointers", SpvWord{4442}}, + {"CapabilityDotProductInputAllKHR", SpvWord{6016}}, + {"DecorationSaturatedConversion", SpvWord{28}}, + {"QuantizationModesRND_CONV_ODD", SpvWord{7}}, + {"MemorySemanticsAcquireRelease", SpvWord{8}}, + {"CapabilityMinLod", SpvWord{42}}, + {"BuiltInGlobalInvocationId", SpvWord{28}}, + {"DecorationFPRoundingMode", SpvWord{39}}, + {"ScopeDevice", SpvWord{1}}, + {"ImageFormatRg16i", SpvWord{26}}, + {"MemorySemanticsImageMemory", SpvWord{2048}}, + {"CapabilityAtomicFloat16MinMaxEXT", SpvWord{5616}}, + {"ExecutionModeDenormFlushToZero", SpvWord{4460}}, + {"BuiltInEnqueuedWorkgroupSize", SpvWord{32}}, + {"BuiltInSubgroupGeMask", SpvWord{4417}}, + {"ImageChannelOrderRGBA", SpvWord{5}}, + {"ImageOperandsOffset", SpvWord{16}}, + {"FunctionControlConst", SpvWord{8}}, + {"MemorySemanticsWorkgroupMemory", SpvWord{256}}, + {"ImageFormatRgba16ui", SpvWord{31}}, + {"CapabilityDemoteToHelperInvocation", SpvWord{5379}}, + {"BuiltInBaryCoordSmoothCentroidAMD", SpvWord{4996}}, + {"CapabilityRayQueryProvisionalKHR", SpvWord{4471}}, + {"CooperativeMatrixUseMatrixAccumulatorKHR", SpvWord{2}}, + {"CapabilityDotProductKHR", SpvWord{6019}}, + {"ImageChannelDataTypeUnsignedIntRaw12EXT", SpvWord{20}}, + {"BuiltInSubgroupLeMask", SpvWord{4419}}, + {"AddressingModelPhysical64", SpvWord{2}}, + {"MemoryAccessAliasScopeINTELMask", SpvWord{65536}}, + {"MemorySemanticsVolatile", SpvWord{32768}}, + {"FragmentShadingRateVertical4Pixels", SpvWord{2}}, + {"CapabilityDotProductInput4x8BitPacked", SpvWord{6018}}, + {"CapabilityGroupNonUniformShuffle", SpvWord{65}}, + {"CapabilitySubgroupAvcMotionEstimationIntraINTEL", SpvWord{5697}}, + {"DecorationRelaxedPrecision", SpvWord{0}}, + {"BuiltInBaryCoordPullModelAMD", SpvWord{4998}}, + {"ExecutionModelAnyHitKHR", SpvWord{5315}}, + {"CapabilityInputAttachmentArrayDynamicIndexingEXT", SpvWord{5303}}, + {"LoopControlIterationMultiple", SpvWord{64}}, + {"ScopeQueueFamilyKHR", SpvWord{5}}, + {"RayFlagsSkipClosestHitShaderKHR", SpvWord{8}}, + {"ExecutionModeLocalSizeHint", SpvWord{18}}, + {"SourceLanguageGLSL", SpvWord{2}}, + {"StorageClassWorkgroup", SpvWord{4}}, + {"MemoryModelGLSL450", SpvWord{1}}, + {"BuiltInCoreCountARM", SpvWord{4161}}, + {"CapabilityIntegerFunctions2INTEL", SpvWord{5584}}, + {"DecorationVolatile", SpvWord{21}}, + {"MemorySemanticsRelease", SpvWord{4}}, + {"RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR", SpvWord{2}}, + {"LoopControlMinIterations", SpvWord{16}}, + {"CapabilityUniformTexelBufferArrayNonUniformIndexing", SpvWord{5311}}, + {"KernelEnqueueFlagsWaitKernel", SpvWord{1}}, + {"ExecutionModeMaxWorkDimINTEL", SpvWord{5894}}, + {"CapabilityFloatingPointModeINTEL", SpvWord{5583}}, + {"BuiltInGlobalSize", SpvWord{31}}, + {"CapabilityGeometryStreams", SpvWord{54}}, + {"FunctionParameterAttributeSext", SpvWord{1}}, + {"CapabilityFragmentBarycentricKHR", SpvWord{5284}}, + {"StorageClassPhysicalStorageBufferEXT", SpvWord{5349}}, + {"CapabilityComputeDerivativeGroupQuadsNV", SpvWord{5288}}, + {"ExecutionModelFragment", SpvWord{4}}, + {"CapabilityStorageBufferArrayDynamicIndexing", SpvWord{30}}, + {"ScopeWorkgroup", SpvWord{2}}, + {"DecorationSIMTCallINTEL", SpvWord{5599}}, + {"MemoryAccessMakePointerAvailableKHR", SpvWord{8}}, + {"DecorationRegisterMapKernelArgumentINTEL", SpvWord{6176}}, + {"ImageChannelOrderDepth", SpvWord{13}}, + {"CapabilityStorageImageArrayNonUniformIndexingEXT", SpvWord{5309}}, + {"CapabilityPipes", SpvWord{17}}, + {"ExecutionModeSharedLocalMemorySizeINTEL", SpvWord{5618}}, + {"DecorationVectorComputeFunctionINTEL", SpvWord{5626}}, + {"CapabilityLiteralSampler", SpvWord{20}}, + {"CapabilityWorkgroupMemoryExplicitLayoutKHR", SpvWord{4428}}, + {"DecorationRowMajor", SpvWord{4}}, + {"ImageFormatRgba8i", SpvWord{23}}, + {"ImageFormatRgba32ui", SpvWord{30}}, + {"AccessQualifierReadOnly", SpvWord{0}}, + {"BuiltInPrimitiveShadingRateKHR", SpvWord{4432}}, + {"SamplerAddressingModeClamp", SpvWord{2}}, + {"FunctionControlPure", SpvWord{4}}, + {"GroupOperationPartitionedReduceNV", SpvWord{6}}, + {"SelectionControlNone", SpvWord{0}}, + {"ExecutionModePixelInterlockUnorderedEXT", SpvWord{5367}}, + {"ExecutionModeLocalSizeHintId", SpvWord{39}}, + {"MemoryModelOpenCL", SpvWord{2}}, + {"FragmentShadingRateHorizontal2Pixels", SpvWord{4}}, + {"CapabilityMultiViewport", SpvWord{57}}, + {"CooperativeMatrixUseMatrixBKHR", SpvWord{1}}, + {"DecorationAlignment", SpvWord{44}}, + {"QuantizationModesRND_MIN_INF", SpvWord{5}}, + {"BuiltInSMCountNV", SpvWord{5375}}, + {"DecorationPerVertexNV", SpvWord{5285}}, + {"CapabilityVariablePointersStorageBuffer", SpvWord{4441}}, + {"BuiltInBaseInstance", SpvWord{4425}}, + {"DecorationAliasedPointer", SpvWord{5356}}, + {"CapabilitySubgroupShuffleINTEL", SpvWord{5568}}, + {"CapabilityRayQueryPositionFetchKHR", SpvWord{5391}}, + {"CapabilityTextureBlockMatchQCOM", SpvWord{4486}}, + {"ExecutionModeSubgroupsPerWorkgroup", SpvWord{36}}, + {"MemorySemanticsOutputMemoryKHR", SpvWord{4096}}, + {"ExecutionModeQuads", SpvWord{24}}, + {"ImageChannelDataTypeUnormInt101010", SpvWord{6}}, + {"ImageFormatRgba8", SpvWord{4}}, + {"BuiltInWorkgroupSize", SpvWord{25}}, + {"ExecutionModeNoGlobalOffsetINTEL", SpvWord{5895}}, + {"DecorationForcePow2DepthINTEL", SpvWord{5836}}, + {"BuiltInGlobalOffset", SpvWord{33}}, + {"BuiltInBaryCoordKHR", SpvWord{5286}}, + {"LoopControlInitiationIntervalINTEL", SpvWord{65536}}, + {"BuiltInWorldToObjectNV", SpvWord{5331}}, + {"ExecutionModeSchedulerTargetFmaxMhzINTEL", SpvWord{5903}}, + {"CapabilityStorageBuffer8BitAccess", SpvWord{4448}}, + {"CapabilityLinkage", SpvWord{5}}, + {"SourceLanguageOpenCL_C", SpvWord{3}}, + {"DecorationBankBitsINTEL", SpvWord{5835}}, + {"SamplerAddressingModeRepeatMirrored", SpvWord{4}}, + {"ExecutionModeDenormPreserve", SpvWord{4459}}, + {"ExecutionModeOutputTriangleStrip", SpvWord{29}}, + {"ImageFormatR16f", SpvWord{9}}, + {"DecorationFuncParamIOKindINTEL", SpvWord{5625}}, + {"ExecutionModelIntersectionNV", SpvWord{5314}}, + {"RayQueryIntersectionRayQueryCommittedIntersectionKHR", SpvWord{1}}, + {"BuiltInPrimitiveTriangleIndicesEXT", SpvWord{5296}}, + {"BuiltInPrimitiveId", SpvWord{7}}, + {"ImageOperandsLod", SpvWord{2}}, + {"AccessQualifierReadWrite", SpvWord{2}}, + {"CapabilitySplitBarrierINTEL", SpvWord{6141}}, + {"CapabilityGroupNonUniformQuad", SpvWord{68}}, + {"DecorationCentroid", SpvWord{16}}, + {"BuiltInSubgroupId", SpvWord{40}}, + {"LoopControlPeelCount", SpvWord{128}}, + {"LinkageTypeImport", SpvWord{1}}, + {"ExecutionModeRoundingModeRTPINTEL", SpvWord{5620}}, + {"ScopeQueueFamily", SpvWord{5}}, + {"DecorationSecondaryViewportRelativeNV", SpvWord{5256}}, + {"CapabilityStoragePushConstant8", SpvWord{4450}}, + {"BuiltInInvocationId", SpvWord{8}}, + {"MemoryModelVulkanKHR", SpvWord{3}}, + {"ExecutionModelVertex", SpvWord{0}}, + {"DecorationXfbBuffer", SpvWord{36}}, + {"DecorationSingleElementVectorINTEL", SpvWord{6085}}, + {"CapabilityInterpolationFunction", SpvWord{52}}, + {"CapabilityFPGAKernelAttributesv2INTEL", SpvWord{6161}}, + {"ImageFormatR32f", SpvWord{3}}, + {"CapabilityFPGARegINTEL", SpvWord{5948}}, + {"LoopControlNone", SpvWord{0}}, + {"BuiltInSubgroupLtMask", SpvWord{4420}}, + {"FunctionParameterAttributeByVal", SpvWord{2}}, + {"DecorationNumbanksINTEL", SpvWord{5827}}, + {"BuiltInInstanceId", SpvWord{6}}, + {"ImageChannelDataTypeUnormInt24", SpvWord{15}}, + {"ScopeSubgroup", SpvWord{3}}, + {"ExecutionModeStencilRefUnchangedBackAMD", SpvWord{5082}}, + {"LoopControlNoFusionINTEL", SpvWord{8388608}}, + {"CapabilityMeshShadingEXT", SpvWord{5283}}, + {"DecorationIndex", SpvWord{32}}, + {"ImageOperandsBias", SpvWord{1}}, + {"LinkageTypeExport", SpvWord{0}}, + {"ExecutionModeOriginUpperLeft", SpvWord{7}}, + {"BuiltInCoreIDARM", SpvWord{4160}}, + {"BuiltInHitKindKHR", SpvWord{5333}}, + {"BuiltInSubgroupGtMaskKHR", SpvWord{4418}}, + {"CapabilityFPGALatencyControlINTEL", SpvWord{6171}}, + {"SourceLanguageOpenCL_CPP", SpvWord{4}}, + {"ImageFormatRg8Snorm", SpvWord{18}}, + {"BuiltInRayTmaxNV", SpvWord{5326}}, + {"CapabilityTransformFeedback", SpvWord{53}}, + {"FPFastMathModeAllowRecip", SpvWord{8}}, + {"SourceLanguageWGSL", SpvWord{10}}, + {"CooperativeMatrixOperandsMatrixCSignedComponentsKHR", SpvWord{4}}, + {"BuiltInBaryCoordNV", SpvWord{5286}}, + {"ImageChannelDataTypeUnormShort565", SpvWord{4}}, + {"DecorationRestrictPointer", SpvWord{5355}}, + {"CapabilityRayQueryKHR", SpvWord{4472}}, + {"ExecutionModelClosestHitKHR", SpvWord{5316}}, + {"CapabilityArbitraryPrecisionFixedPointINTEL", SpvWord{5922}}, + {"CapabilityRayTracingOpacityMicromapEXT", SpvWord{5381}}, + {"DecorationPerPrimitiveNV", SpvWord{5271}}, + {"DecorationMathOpDSPModeINTEL", SpvWord{5909}}, + {"ImageOperandsVolatileTexel", SpvWord{2048}}, + {"BuiltInTessLevelInner", SpvWord{12}}, + {"ExecutionModePostDepthCoverage", SpvWord{4446}}, + {"CapabilityLoopFuseINTEL", SpvWord{5906}}, + {"CapabilityFunctionFloatControlINTEL", SpvWord{5821}}, + {"CapabilityPhysicalStorageBufferAddresses", SpvWord{5347}}, + {"ImageChannelOrderARGB", SpvWord{7}}, + {"StorageClassIncomingCallableDataNV", SpvWord{5329}}, + {"DecorationFunctionRoundingModeINTEL", SpvWord{5822}}, + {"ExecutionModeDepthUnchanged", SpvWord{16}}, + {"ImageChannelOrdersRGBx", SpvWord{16}}, + {"DecorationMemoryINTEL", SpvWord{5826}}, + {"CapabilityTileImageColorReadAccessEXT", SpvWord{4166}}, + {"CooperativeMatrixOperandsMatrixASignedComponentsKHR", SpvWord{1}}, + {"StorageClassFunction", SpvWord{7}}, + {"CapabilityGenericPointer", SpvWord{38}}, + {"CapabilityFPGAKernelAttributesINTEL", SpvWord{5897}}, + {"CapabilitySubgroupImageMediaBlockIOINTEL", SpvWord{5579}}, + {"CapabilityVector16", SpvWord{7}}, + {"ExecutionModeSubgroupUniformControlFlowKHR", SpvWord{4421}}, + {"CapabilityKernel", SpvWord{6}}, + {"BuiltInWorkDim", SpvWord{30}}, + {"CapabilityPhysicalStorageBufferAddressesEXT", SpvWord{5347}}, + {"SamplerAddressingModeClampToEdge", SpvWord{1}}, + {"DecorationMMHostInterfaceAddressWidthINTEL", SpvWord{6177}}, + {"CapabilityGroupNonUniformVote", SpvWord{62}}, + {"ImageFormatRgb10a2ui", SpvWord{34}}, + {"DecorationNonUniformEXT", SpvWord{5300}}, + {"CooperativeMatrixOperandsNoneKHR", SpvWord{0}}, + {"CapabilityShaderClockKHR", SpvWord{5055}}, + {"MemorySemanticsUniformMemory", SpvWord{64}}, + {"DecorationSideEffectsINTEL", SpvWord{5608}}, + {"StorageClassShaderRecordBufferNV", SpvWord{5343}}, + {"CapabilityShaderSMBuiltinsNV", SpvWord{5373}}, + {"CapabilityAtomicFloat64MinMaxEXT", SpvWord{5613}}, + {"SourceLanguageESSL", SpvWord{1}}, + {"DecorationMMHostInterfaceMaxBurstINTEL", SpvWord{6181}}, + {"DecorationMaxByteOffsetId", SpvWord{47}}, + {"ImageOperandsMakeTexelAvailable", SpvWord{256}}, + {"CapabilityImageBuffer", SpvWord{47}}, + {"CapabilityStorageTexelBufferArrayNonUniformIndexingEXT", SpvWord{5312}}, + {"BuiltInInstanceCustomIndexNV", SpvWord{5327}}, + {"ExecutionModeDepthLess", SpvWord{15}}, + {"ImageFormatR8ui", SpvWord{39}}, + {"GroupOperationReduce", SpvWord{0}}, + {"CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR", SpvWord{4430}}, + {"CapabilityInputAttachmentArrayDynamicIndexing", SpvWord{5303}}, + {"LoopControlLoopCoalesceINTEL", SpvWord{1048576}}, + {"FunctionParameterAttributeNoReadWrite", SpvWord{7}}, + {"CapabilityAtomicStorage", SpvWord{21}}, + {"DecorationSinglepumpINTEL", SpvWord{5830}}, + {"ExecutionModeLocalSize", SpvWord{17}}, + {"SamplerFilterModeLinear", SpvWord{1}}, + {"DecorationGLSLPacked", SpvWord{9}}, + {"SelectionControlDontFlatten", SpvWord{2}}, + {"ExecutionModelClosestHitNV", SpvWord{5316}}, + {"DecorationBlockMatchTextureQCOM", SpvWord{4488}}, + {"FunctionParameterAttributeNoAlias", SpvWord{4}}, + {"ImageFormatRg8ui", SpvWord{37}}, + {"CapabilityArbitraryPrecisionIntegersINTEL", SpvWord{5844}}, + {"LoopControlPartialCount", SpvWord{256}}, + {"CapabilityImageQuery", SpvWord{50}}, + {"StorageClassTileImageEXT", SpvWord{4172}}, + {"ImageFormatRgba16f", SpvWord{2}}, + {"KernelProfilingInfoCmdExecTime", SpvWord{1}}, + {"DecorationNoUnsignedWrap", SpvWord{4470}}, + {"ExecutionModeOutputLinesNV", SpvWord{5269}}, + {"BuiltInWarpIDNV", SpvWord{5376}}, + {"BuiltInSubgroupGeMaskKHR", SpvWord{4417}}, + {"CapabilityNamedBarrier", SpvWord{59}}, + {"CapabilityDotProductInput4x8BitKHR", SpvWord{6017}}, + {"BuiltInNumSubgroups", SpvWord{38}}, + {"CapabilityStorageBufferArrayNonUniformIndexing", SpvWord{5308}}, + {"CapabilityRayTracingKHR", SpvWord{4479}}, + {"ImageChannelDataTypeUnsignedIntRaw10EXT", SpvWord{19}}, + {"QuantizationModesRND_INF", SpvWord{4}}, + {"ExecutionModeSignedZeroInfNanPreserve", SpvWord{4461}}, + {"CapabilityDotProduct", SpvWord{6019}}, + {"CapabilityAtomicFloat32MinMaxEXT", SpvWord{5612}}, + {"FPFastMathModeAllowReassocINTEL", SpvWord{131072}}, + {"MemorySemanticsCrossWorkgroupMemory", SpvWord{512}}, + {"OverflowModesSAT", SpvWord{1}}, + {"CapabilityFPGALoopControlsINTEL", SpvWord{5888}}, + {"DecorationStableKernelArgumentINTEL", SpvWord{6183}}, + {"CapabilityBindlessTextureNV", SpvWord{5390}}, + {"ImageFormatR32i", SpvWord{24}}, + {"DecorationComponent", SpvWord{31}}, + {"StorageClassHitObjectAttributeNV", SpvWord{5385}}, + {"SelectionControlFlatten", SpvWord{1}}, + {"DecorationStackCallINTEL", SpvWord{5627}}, + {"CapabilityMemoryAccessAliasingINTEL", SpvWord{5910}}, + {"ImageFormatR64ui", SpvWord{40}}, + {"StorageClassDeviceOnlyINTEL", SpvWord{5936}}, + {"DecorationVectorComputeCallableFunctionINTEL", SpvWord{6087}}, + {"BuiltInViewportMaskPerViewNV", SpvWord{5262}}, + {"BuiltInRayTmaxKHR", SpvWord{5326}}, + {"DecorationPatch", SpvWord{15}}, + {"CapabilityGeometry", SpvWord{2}}, + {"ExecutionModeFinalizer", SpvWord{34}}, + {"ImageChannelOrderABGR", SpvWord{19}}, + {"ImageOperandsSample", SpvWord{64}}, + {"ExecutionModeSpacingFractionalEven", SpvWord{2}}, + {"ImageChannelDataTypeUnsignedInt8", SpvWord{10}}, + {"DecorationOverrideCoverageNV", SpvWord{5248}}, + {"FunctionParameterAttributeNoCapture", SpvWord{5}}, + {"ImageFormatRgba8ui", SpvWord{32}}, + {"CapabilityFragmentShaderPixelInterlockEXT", SpvWord{5378}}, + {"FunctionControlDontInline", SpvWord{2}}, + {"DecorationWeightTextureQCOM", SpvWord{4487}}, + {"CapabilityShaderInvocationReorderNV", SpvWord{5383}}, + {"DecorationExplicitInterpAMD", SpvWord{4999}}, + {"CapabilityDeviceEnqueue", SpvWord{19}}, + {"CapabilityFloat16", SpvWord{9}}, + {"CapabilityRayTracingNV", SpvWord{5340}}, + {"StorageClassCodeSectionINTEL", SpvWord{5605}}, + {"BuiltInPatchVertices", SpvWord{14}}, + {"DecorationBindlessSamplerNV", SpvWord{5398}}, + {"RayFlagsCullOpaqueKHR", SpvWord{64}}, + {"CapabilityStorageBuffer16BitAccess", SpvWord{4433}}, + {"ExecutionModelTaskEXT", SpvWord{5364}}, + {"ExecutionModeStreamingInterfaceINTEL", SpvWord{6154}}, + {"BuiltInClipDistancePerViewNV", SpvWord{5277}}, + {"CapabilitySampledRect", SpvWord{37}}, + {"CapabilityGroupNonUniformPartitionedNV", SpvWord{5297}}, + {"BuiltInWorldRayDirectionKHR", SpvWord{5322}}, + {"ExecutionModelRayGenerationNV", SpvWord{5313}}, + {"BuiltInWorldRayOriginKHR", SpvWord{5321}}, + {"ImageChannelDataTypeSnormInt8", SpvWord{0}}, + {"BuiltInSecondaryViewportMaskNV", SpvWord{5258}}, + {"DecorationMergeINTEL", SpvWord{5834}}, + {"FunctionParameterAttributeNoWrite", SpvWord{6}}, + {"DecorationFPMaxErrorDecorationINTEL", SpvWord{6170}}, + {"ExecutionModeOutputLinesEXT", SpvWord{5269}}, + {"DecorationDescriptorSet", SpvWord{34}}, + {"CapabilityVectorAnyINTEL", SpvWord{5619}}, + {"QuantizationModesRND", SpvWord{2}}, + {"DimCube", SpvWord{3}}, + {"ExecutionModeOriginLowerLeft", SpvWord{8}}, + {"ImageFormatRg32ui", SpvWord{35}}, + {"CapabilityAtomicFloat16AddEXT", SpvWord{6095}}, + {"FunctionParameterAttributeSret", SpvWord{3}}, + {"ImageOperandsConstOffsets", SpvWord{32}}, + {"DecorationAliasedPointerEXT", SpvWord{5356}}, + {"BuiltInWarpMaxIDARM", SpvWord{4164}}, + {"ImageFormatRg8i", SpvWord{27}}, + {"ImageChannelOrdersRGBA", SpvWord{17}}, + {"StorageClassPrivate", SpvWord{6}}, + {"BuiltInPositionPerViewNV", SpvWord{5261}}, + {"ExecutionModeIsolines", SpvWord{25}}, + {"ScopeCrossDevice", SpvWord{0}}, + {"BuiltInObjectToWorldNV", SpvWord{5330}}, + {"CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR", SpvWord{4429}}, + {"CapabilityUniformAndStorageBuffer8BitAccess", SpvWord{4449}}, + {"ImageChannelDataTypeUnsignedInt32", SpvWord{12}}, + {"FPRoundingModeRTP", SpvWord{2}}, + {"ExecutionModeRoundingModeRTNINTEL", SpvWord{5621}}, + {"DecorationLinkageAttributes", SpvWord{41}}, + {"DecorationFunctionFloatingPointModeINTEL", SpvWord{6080}}, + {"CapabilityRayTracingMotionBlurNV", SpvWord{5341}}, + {"StorageClassCallableDataKHR", SpvWord{5328}}, + {"CapabilityVulkanMemoryModelDeviceScope", SpvWord{5346}}, + {"LoopControlUnroll", SpvWord{1}}, + {"ImageChannelOrdersBGRA", SpvWord{18}}, + {"MemorySemanticsAcquire", SpvWord{2}}, + {"FPFastMathModeNotInf", SpvWord{2}}, + {"DecorationClobberINTEL", SpvWord{5607}}, + {"BuiltInCullPrimitiveEXT", SpvWord{5299}}, + {"FPRoundingModeRTE", SpvWord{0}}, + {"ExecutionModeSubgroupsPerWorkgroupId", SpvWord{37}}, + {"GroupOperationPartitionedInclusiveScanNV", SpvWord{7}}, + {"CapabilityInt64ImageEXT", SpvWord{5016}}, + {"CapabilityStorageUniformBufferBlock16", SpvWord{4433}}, + {"DecorationColMajor", SpvWord{5}}, + {"FunctionControlInline", SpvWord{1}}, + {"CapabilityShader", SpvWord{1}}, + {"ExecutionModeOutputLineStrip", SpvWord{28}}, + {"CapabilityFPFastMathModeINTEL", SpvWord{5837}}, + {"CapabilityFPGAMemoryAccessesINTEL", SpvWord{5898}}, + {"FPDenormModePreserve", SpvWord{0}}, + {"ExecutionModeNonCoherentColorAttachmentReadEXT", SpvWord{4169}}, + {"StorageClassHitAttributeKHR", SpvWord{5339}}, + {"CapabilityShaderStereoViewNV", SpvWord{5259}}, + {"ExecutionModeXfb", SpvWord{11}}, + {"MemorySemanticsMakeVisibleKHR", SpvWord{16384}}, + {"StorageClassUniform", SpvWord{2}}, + {"BuiltInCullMaskKHR", SpvWord{6021}}, + {"DecorationPerPrimitiveEXT", SpvWord{5271}}, + {"BuiltInBaryCoordNoPerspKHR", SpvWord{5287}}, + {"DecorationViewportRelativeNV", SpvWord{5252}}, + {"ExecutionModeStencilRefLessBackAMD", SpvWord{5084}}, + {"ImageFormatRgba32i", SpvWord{21}}, + {"BuiltInDrawIndex", SpvWord{4426}}, + {"ImageFormatRg16f", SpvWord{7}}, + {"ExecutionModePointMode", SpvWord{10}}, + {"BuiltInBaryCoordNoPerspSampleAMD", SpvWord{4994}}, + {"BuiltInTaskCountNV", SpvWord{5274}}, + {"DecorationBindlessImageNV", SpvWord{5399}}, + {"CapabilityImageReadWrite", SpvWord{14}}, + {"RayFlagsTerminateOnFirstHitKHR", SpvWord{4}}, + {"ImageFormatRg16", SpvWord{12}}, + {"KernelProfilingInfoNone", SpvWord{0}}, + {"CapabilityBitInstructions", SpvWord{6025}}, + {"ImageFormatR32ui", SpvWord{33}}, + {"CapabilityGeometryShaderPassthroughNV", SpvWord{5251}}, + {"BuiltInSubgroupSize", SpvWord{36}}, + {"FunctionControlOptNoneINTEL", SpvWord{65536}}, + {"ImageChannelDataTypeFloat", SpvWord{14}}, + {"ImageChannelOrderRx", SpvWord{10}}, + {"ImageFormatR16", SpvWord{14}}, + {"BuiltInIncomingRayFlagsNV", SpvWord{5351}}, + {"CapabilityFloat16Buffer", SpvWord{8}}, + {"DecorationMMHostInterfaceDataWidthINTEL", SpvWord{6178}}, + {"DecorationPassthroughNV", SpvWord{5250}}, + {"StorageClassOutput", SpvWord{3}}, + {"MemoryAccessNonPrivatePointerKHR", SpvWord{32}}, + {"CapabilityRoundingModeRTE", SpvWord{4467}}, + {"StorageClassRayPayloadKHR", SpvWord{5338}}, + {"CooperativeMatrixUseMatrixAKHR", SpvWord{0}}, + {"StorageClassCrossWorkgroup", SpvWord{5}}, + {"BuiltInLaunchSizeNV", SpvWord{5320}}, + {"QuantizationModesRND_ZERO", SpvWord{3}}, + {"BuiltInSampleId", SpvWord{18}}, + {"DecorationGlobalVariableOffsetINTEL", SpvWord{5628}}, + {"ImageFormatR16i", SpvWord{28}}, + {"ExecutionModeRoundingModeRTZ", SpvWord{4463}}, + {"BuiltInViewIndex", SpvWord{4440}}, + {"ImageFormatR8i", SpvWord{29}}, + {"CapabilityRayTraversalPrimitiveCullingKHR", SpvWord{4478}}, + {"CapabilityRoundingModeRTZ", SpvWord{4468}}, + {"ExecutionModeContractionOff", SpvWord{31}}, + {"AddressingModelPhysicalStorageBuffer64", SpvWord{5348}}, + {"ImageFormatUnknown", SpvWord{0}}, + {"BuiltInInstanceCustomIndexKHR", SpvWord{5327}}, + {"DecorationXfbStride", SpvWord{37}}, + {"CapabilityAtomicFloat64AddEXT", SpvWord{6034}}, + {"RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR", SpvWord{1}}, + {"FPFastMathModeNotNaN", SpvWord{1}}, + {"DecorationMMHostInterfaceReadWriteModeINTEL", SpvWord{6180}}, + {"DecorationLatencyControlConstraintINTEL", SpvWord{6173}}, + {"LoopControlMaxReinvocationDelayINTEL", SpvWord{33554432}}, + {"CapabilityStorageTexelBufferArrayNonUniformIndexing", SpvWord{5312}}, + {"CapabilityUSMStorageClassesINTEL", SpvWord{5935}}, + {"CapabilityImageRect", SpvWord{36}}, + {"CapabilityFloat64", SpvWord{10}}, + {"ImageOperandsMakeTexelVisible", SpvWord{512}}, + {"LoopControlDontUnroll", SpvWord{2}}, + {"StorageClassPushConstant", SpvWord{9}}, + {"BuiltInWorkgroupId", SpvWord{26}}, + {"ImageFormatR16ui", SpvWord{38}}, + {"CapabilityInt64", SpvWord{11}}, + {"BuiltInSubgroupEqMaskKHR", SpvWord{4416}}, + {"MemorySemanticsMakeVisible", SpvWord{16384}}, + {"DecorationNoSignedWrap", SpvWord{4469}}, + {"ImageChannelDataTypeUnsignedInt16", SpvWord{11}}, + {"OverflowModesSAT_ZERO", SpvWord{2}}, + {"MemoryAccessNoAliasINTELMask", SpvWord{131072}}, + {"CapabilityRuntimeDescriptorArray", SpvWord{5302}}, + {"CapabilitySubgroupAvcMotionEstimationINTEL", SpvWord{5696}}, + {"ExecutionModelIntersectionKHR", SpvWord{5314}}, + {"StorageClassImage", SpvWord{11}}, + {"BuiltInPrimitiveCountNV", SpvWord{5275}}, + {"DecorationHlslCounterBufferGOOGLE", SpvWord{5634}}, + {"CapabilityGroupNonUniformClustered", SpvWord{67}}, + {"LoopControlLoopCountINTEL", SpvWord{16777216}}, + {"RayFlagsSkipTrianglesKHR", SpvWord{256}}, + {"ExecutionModeShadingRateInterlockOrderedEXT", SpvWord{5370}}, + {"ExecutionModeMaxWorkgroupSizeINTEL", SpvWord{5893}}, + {"BuiltInLocalInvocationId", SpvWord{27}}, + {"CapabilityFragmentShadingRateKHR", SpvWord{4422}}, + {"CapabilityShaderNonUniform", SpvWord{5301}}, + {"ExecutionModeVertexOrderCcw", SpvWord{5}}, + {"FPDenormModeFlushToZero", SpvWord{1}}, + {"CooperativeMatrixOperandsMatrixResultSignedComponentsKHR", SpvWord{8}}, + {"RayQueryIntersectionRayQueryCandidateIntersectionKHR", SpvWord{0}}, + {"CapabilityAsmINTEL", SpvWord{5606}}, + {"BuiltInPosition", SpvWord{0}}, + {"BuiltInPrimitiveLineIndicesEXT", SpvWord{5295}}, + {"DecorationAliasScopeINTEL", SpvWord{5914}}, + {"CapabilityGroupUniformArithmeticKHR", SpvWord{6400}}, + {"BuiltInMeshViewIndicesNV", SpvWord{5281}}, + {"DimTileImageDataEXT", SpvWord{4173}}, + {"DecorationMMHostInterfaceWaitRequestINTEL", SpvWord{6182}}, + {"CapabilityArbitraryPrecisionFloatingPointINTEL", SpvWord{5845}}, + {"SourceLanguageNZSL", SpvWord{9}}, + {"CapabilityFragmentFullyCoveredEXT", SpvWord{5265}}, + {"BuiltInPointCoord", SpvWord{16}}, + {"CapabilitySubgroupDispatch", SpvWord{58}}, + {"CapabilityImageReadWriteLodAMD", SpvWord{5015}}, + {"CapabilityInputAttachmentArrayNonUniformIndexingEXT", SpvWord{5310}}, + {"ScopeInvocation", SpvWord{4}}, + {"ExecutionModelTaskNV", SpvWord{5267}}, + {"CapabilityStorageTexelBufferArrayDynamicIndexing", SpvWord{5305}}, + {"CapabilityTessellation", SpvWord{3}}, + {"CapabilitySubgroupImageBlockIOINTEL", SpvWord{5570}}, + {"ImageChannelOrderIntensity", SpvWord{8}}, + {"CapabilityRayTracingProvisionalKHR", SpvWord{5353}}, + {"CapabilityDotProductInput4x8Bit", SpvWord{6017}}, + {"FPRoundingModeRTN", SpvWord{3}}, + {"BuiltInVertexIndex", SpvWord{42}}, + {"ExecutionModeStencilRefReplacingEXT", SpvWord{5027}}, + {"MemorySemanticsRelaxed", SpvWord{0}}, + {"CapabilityFragmentShaderSampleInterlockEXT", SpvWord{5363}}, + {"ImageOperandsZeroExtend", SpvWord{8192}}, + {"CapabilityVulkanMemoryModelDeviceScopeKHR", SpvWord{5346}}, + {"RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR", SpvWord{1}}, + {"BuiltInBaseVertex", SpvWord{4424}}, + {"ExecutionModeNumSIMDWorkitemsINTEL", SpvWord{5896}}, + {"DecorationSample", SpvWord{17}}, + {"BuiltInSubgroupLtMaskKHR", SpvWord{4420}}, + {"ImageChannelDataTypeUnormInt16", SpvWord{3}}, + {"ImageOperandsNone", SpvWord{0}}, + {"CapabilityImageMSArray", SpvWord{48}}, + {"ImageFormatRgba8Snorm", SpvWord{5}}, + {"CapabilityUniformTexelBufferArrayNonUniformIndexingEXT", SpvWord{5311}}, + {"DecorationNonWritable", SpvWord{24}}, + {"BuiltInSubgroupMaxSize", SpvWord{37}}, + {"CapabilityTileImageDepthReadAccessEXT", SpvWord{4167}}, + {"Dim2D", SpvWord{1}}, + {"DecorationStream", SpvWord{29}}, + {"CapabilityUniformBufferArrayDynamicIndexing", SpvWord{28}}, + {"CapabilityStorageImageExtendedFormats", SpvWord{49}}, + {"CapabilityFloat16ImageAMD", SpvWord{5008}}, + {"ExecutionModelAnyHitNV", SpvWord{5315}}, + {"DecorationInputAttachmentIndex", SpvWord{43}}, + {"BuiltInRayTminKHR", SpvWord{5325}}, + {"BuiltInSubgroupLocalInvocationId", SpvWord{41}}, + {"BuiltInViewportIndex", SpvWord{10}}, + {"CapabilityMultiView", SpvWord{4439}}, + {"AddressingModelPhysicalStorageBuffer64EXT", SpvWord{5348}}, + {"DimBuffer", SpvWord{5}}, + {"DecorationLatencyControlLabelINTEL", SpvWord{6172}}, + {"DecorationSimpleDualPortINTEL", SpvWord{5833}}, + {"BuiltInWorldRayOriginNV", SpvWord{5321}}, + {"BuiltInObjectRayOriginNV", SpvWord{5323}}, + {"RayFlagsForceOpacityMicromap2StateEXT", SpvWord{1024}}, + {"CapabilityGeometryPointSize", SpvWord{24}}, + {"LinkageTypeLinkOnceODR", SpvWord{2}}, + {"ExecutionModeStencilRefUnchangedFrontAMD", SpvWord{5079}}, + {"FPFastMathModeNone", SpvWord{0}}, + {"DecorationNoAliasINTEL", SpvWord{5915}}, + {"CapabilityShaderLayer", SpvWord{69}}, + {"DecorationHitObjectShaderRecordBufferNV", SpvWord{5386}}, + {"ImageChannelDataTypeUnormInt101010_2", SpvWord{16}}, + {"BuiltInSamplePosition", SpvWord{19}}, + {"CapabilityUniformTexelBufferArrayDynamicIndexingEXT", SpvWord{5304}}, + {"DecorationUniform", SpvWord{26}}, + {"ImageOperandsMakeTexelAvailableKHR", SpvWord{256}}, + {"CapabilityUniformBufferArrayNonUniformIndexing", SpvWord{5306}}, + {"DecorationPrefetchINTEL", SpvWord{5902}}, + {"CapabilityDebugInfoModuleINTEL", SpvWord{6114}}, + {"StorageClassGeneric", SpvWord{8}}, + {"CapabilitySampled1D", SpvWord{43}}, + {"ImageOperandsNonPrivateTexel", SpvWord{1024}}, + {"LoopControlDependencyInfinite", SpvWord{4}}, + {"StorageClassInput", SpvWord{1}}, + {"LoopControlDependencyLength", SpvWord{8}}, + {"GroupOperationClusteredReduce", SpvWord{3}}, + {"CapabilityDrawParameters", SpvWord{4427}}, + {"CapabilityUniformTexelBufferArrayDynamicIndexing", SpvWord{5304}}, + {"ExecutionModeDerivativeGroupLinearNV", SpvWord{5290}}, + {"DecorationMMHostInterfaceLatencyINTEL", SpvWord{6179}}, + {"CapabilityInt8", SpvWord{39}}, + {"ImageChannelDataTypeSnormInt16", SpvWord{1}}, + {"CapabilityStorageInputOutput16", SpvWord{4436}}, + {"CapabilitySampledImageArrayDynamicIndexing", SpvWord{29}}, + {"ExecutionModeNonCoherentStencilAttachmentReadEXT", SpvWord{4171}}, + {"BuiltInSMIDNV", SpvWord{5377}}, + {"CapabilityKernelAttributesINTEL", SpvWord{5892}}, + {"StorageClassUniformConstant", SpvWord{0}}, + {"CapabilityCooperativeMatrixNV", SpvWord{5357}}, + {"DecorationNoContraction", SpvWord{42}}, + {"ExecutionModelKernel", SpvWord{6}}, + {"DecorationPerTaskNV", SpvWord{5273}}, + {"BuiltInFragInvocationCountEXT", SpvWord{5293}}, + {"BuiltInDeviceIndex", SpvWord{4438}}, + {"CapabilityStorageImageWriteWithoutFormat", SpvWord{56}}, + {"CapabilityGroupNonUniformRotateKHR", SpvWord{6026}}, + {"CapabilityDenormFlushToZero", SpvWord{4465}}, + {"ExecutionModeRoundingModeRTE", SpvWord{4462}}, + {"BuiltInPointSize", SpvWord{1}}, + {"CapabilityComputeDerivativeGroupLinearNV", SpvWord{5350}}, + {"ImageChannelOrderRA", SpvWord{3}}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 944; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool getOpInfo(const SpvOp& k, SPIRVCoreGrammarInfo::OpInfo& v) +{ + switch(k) + { + case SpvOpNop: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpUndef: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSourceContinued: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpSource: + { + const static OperandKind operandTypes[] = {{10}, {48}, {47}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 2, 4, 4, operandTypes}; + return true; + } + case SpvOpSourceExtension: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpName: + { + const static OperandKind operandTypes[] = {{47}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpMemberName: + { + const static OperandKind operandTypes[] = {{47}, {48}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpString: + { + const static OperandKind operandTypes[] = {{44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpLine: + { + const static OperandKind operandTypes[] = {{47}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpExtension: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExtInstImport: + { + const static OperandKind operandTypes[] = {{44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpExtInst: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {51}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpMemoryModel: + { + const static OperandKind operandTypes[] = {{12}, {13}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpEntryPoint: + { + const static OperandKind operandTypes[] = {{11}, {47}, {49}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpExecutionMode: + { + const static OperandKind operandTypes[] = {{47}, {14}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpCapability: + { + const static OperandKind operandTypes[] = {{35}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeVoid: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeBool: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeInt: + { + const static OperandKind operandTypes[] = {{44}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeFloat: + { + const static OperandKind operandTypes[] = {{44}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeVector: + { + const static OperandKind operandTypes[] = {{44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeMatrix: + { + const static OperandKind operandTypes[] = {{44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeImage: + { + const static OperandKind operandTypes[] = {{44}, {47}, {16}, {48}, {48}, {48}, {48}, {19}, {28}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 8, 9, 9, operandTypes}; + return true; + } + case SpvOpTypeSampler: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeSampledImage: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeArray: + { + const static OperandKind operandTypes[] = {{44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeRuntimeArray: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeStruct: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpTypeOpaque: + { + const static OperandKind operandTypes[] = {{44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypePointer: + { + const static OperandKind operandTypes[] = {{44}, {15}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeFunction: + { + const static OperandKind operandTypes[] = {{44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpTypeEvent: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeDeviceEvent: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeReserveId: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeQueue: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypePipe: + { + const static OperandKind operandTypes[] = {{44}, {28}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeForwardPointer: + { + const static OperandKind operandTypes[] = {{47}, {15}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConstantTrue: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConstantFalse: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConstant: + { + const static OperandKind operandTypes[] = {{43}, {44}, {50}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConstantComposite: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpConstantSampler: + { + const static OperandKind operandTypes[] = {{43}, {44}, {17}, {48}, {18}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpConstantNull: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSpecConstantTrue: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSpecConstantFalse: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSpecConstant: + { + const static OperandKind operandTypes[] = {{43}, {44}, {50}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSpecConstantComposite: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpSpecConstantOp: + { + const static OperandKind operandTypes[] = {{43}, {44}, {52}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFunction: + { + const static OperandKind operandTypes[] = {{43}, {44}, {4}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFunctionParameter: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpFunctionEnd: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpFunctionCall: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpVariable: + { + const static OperandKind operandTypes[] = {{43}, {44}, {15}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpImageTexelPointer: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpLoad: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpStore: + { + const static OperandKind operandTypes[] = {{47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpCopyMemory: + { + const static OperandKind operandTypes[] = {{47}, {47}, {6}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 4, 4, operandTypes}; + return true; + } + case SpvOpCopyMemorySized: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {6}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 5, 5, operandTypes}; + return true; + } + case SpvOpAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpInBoundsAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpPtrAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpArrayLength: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGenericPtrMemSemantics: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpInBoundsPtrAccessChain: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpDecorate: + { + const static OperandKind operandTypes[] = {{47}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpMemberDecorate: + { + const static OperandKind operandTypes[] = {{47}, {48}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDecorationGroup: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpGroupDecorate: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpGroupMemberDecorate: + { + const static OperandKind operandTypes[] = {{47}, {54}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpVectorExtractDynamic: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpVectorInsertDynamic: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpVectorShuffle: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpCompositeConstruct: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpCompositeExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpCompositeInsert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 0xffff, 5, operandTypes}; + return true; + } + case SpvOpCopyObject: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTranspose: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSampledImage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageSampleImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSampleDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSampleProjImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleProjExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSampleProjDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSampleProjDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageFetch: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageDrefGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageRead: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageWrite: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpImage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQueryFormat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQueryOrder: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQuerySizeLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageQuerySize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQueryLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageQueryLevels: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageQuerySamples: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertFToU: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertFToS: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertSToF: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToF: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpUConvert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSConvert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFConvert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpQuantizeToF16: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertPtrToU: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSatConvertSToU: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSatConvertUToS: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToPtr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpPtrCastToGeneric: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGenericCastToPtr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGenericCastToPtrExplicit: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {15}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSNegate: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFNegate: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpISub: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFSub: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUDiv: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSDiv: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFDiv: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUMod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSRem: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSMod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFRem: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFMod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpVectorTimesScalar: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpMatrixTimesScalar: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpVectorTimesMatrix: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpMatrixTimesVector: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpMatrixTimesMatrix: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpOuterProduct: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAddCarry: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpISubBorrow: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUMulExtended: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSMulExtended: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAny: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpAll: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsNan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsInf: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsFinite: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIsNormal: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSignBitSet: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpLessOrGreater: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpOrdered: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUnordered: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpLogicalNot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSelect: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpIEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpINotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpULessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSLessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpULessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSLessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdLessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordLessThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordGreaterThan: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdLessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordLessThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFOrdGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFUnordGreaterThanEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpShiftRightLogical: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpShiftRightArithmetic: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpShiftLeftLogical: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitwiseOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitwiseXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpBitwiseAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpNot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpBitFieldInsert: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpBitFieldSExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpBitFieldUExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpBitReverse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpBitCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdx: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdy: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFwidth: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdxFine: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdyFine: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFwidthFine: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdxCoarse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpDPdyCoarse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFwidthCoarse: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpEmitVertex: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpEndPrimitive: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpEmitStreamVertex: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpEndStreamPrimitive: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpControlBarrier: + { + const static OperandKind operandTypes[] = {{46}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpMemoryBarrier: + { + const static OperandKind operandTypes[] = {{46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpAtomicLoad: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicStore: + { + const static OperandKind operandTypes[] = {{47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAtomicExchange: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicCompareExchange: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {45}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpAtomicCompareExchangeWeak: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {45}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpAtomicIIncrement: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicIDecrement: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicISub: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicSMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicUMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicSMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicUMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpPhi: + { + const static OperandKind operandTypes[] = {{43}, {44}, {55}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpLoopMerge: + { + const static OperandKind operandTypes[] = {{47}, {47}, {3}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSelectionMerge: + { + const static OperandKind operandTypes[] = {{47}, {2}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpLabel: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpBranch: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpBranchConditional: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpSwitch: + { + const static OperandKind operandTypes[] = {{47}, {47}, {53}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpKill: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpReturn: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpReturnValue: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpUnreachable: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpLifetimeStart: + { + const static OperandKind operandTypes[] = {{47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpLifetimeStop: + { + const static OperandKind operandTypes[] = {{47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpGroupAsyncCopy: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpGroupWaitEvents: + { + const static OperandKind operandTypes[] = {{46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupAll: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupAny: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupBroadcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpReadPipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpWritePipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpReservedReadPipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpReservedWritePipe: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpReserveReadPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpReserveWritePipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpCommitReadPipe: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpCommitWritePipe: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIsValidReserveId: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGetNumPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGetMaxPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupReserveReadPipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGroupReserveWritePipePackets: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGroupCommitReadPipe: + { + const static OperandKind operandTypes[] = {{46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupCommitWritePipe: + { + const static OperandKind operandTypes[] = {{46}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpEnqueueMarker: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpEnqueueKernel: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 12, 0xffff, 13, operandTypes}; + return true; + } + case SpvOpGetKernelNDrangeSubGroupCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGetKernelNDrangeMaxSubGroupSize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGetKernelWorkGroupSize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpGetKernelPreferredWorkGroupSizeMultiple: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpRetainEvent: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpReleaseEvent: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpCreateUserEvent: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpIsValidEvent: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSetUserEventStatus: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpCaptureEventProfilingInfo: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGetDefaultQueue: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpBuildNDRange: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseSampleDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjDrefImplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseSampleProjDrefExplicitLod: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseFetch: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpImageSparseGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseDrefGather: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpImageSparseTexelsResident: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpNoLine: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpAtomicFlagTestAndSet: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpAtomicFlagClear: + { + const static OperandKind operandTypes[] = {{47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpImageSparseRead: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpSizeOf: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypePipeStorage: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpConstantPipeStorage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCreatePipeFromPipeStorage: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGetKernelLocalSizeForSubgroupCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGetKernelMaxNumSubgroups: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpTypeNamedBarrier: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpNamedBarrierInitialize: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpMemoryNamedBarrier: + { + const static OperandKind operandTypes[] = {{47}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpModuleProcessed: + { + const static OperandKind operandTypes[] = {{49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Debug, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExecutionModeId: + { + const static OperandKind operandTypes[] = {{47}, {14}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpDecorateId: + { + const static OperandKind operandTypes[] = {{47}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpGroupNonUniformElect: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupNonUniformAll: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformAny: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformAllEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBroadcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBroadcastFirst: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformInverseBallot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotBitExtract: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotBitCount: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotFindLSB: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBallotFindMSB: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffle: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffleXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffleUp: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformShuffleDown: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformIAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFAdd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformIMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFMul: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformSMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformUMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFMin: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformSMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformUMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformFMax: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBitwiseAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBitwiseOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformBitwiseXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformLogicalAnd: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformLogicalOr: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformLogicalXor: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpGroupNonUniformQuadBroadcast: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupNonUniformQuadSwap: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCopyLogical: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpPtrEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpPtrNotEqual: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpPtrDiff: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpColorAttachmentReadEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpDepthAttachmentReadEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpStencilAttachmentReadEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpTerminateInvocation: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpSubgroupBallotKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupFirstInvocationKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAllKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAnyKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAllEqualKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupNonUniformRotateKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupReadInvocationKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpTraceRayKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 11, 11, 11, operandTypes}; + return true; + } + case SpvOpExecuteCallableKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConvertUToAccelerationStructureKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpIgnoreIntersectionKHR: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpTerminateRayKHR: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpSDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpUDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpSUDot: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpSDotAccSat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpUDotAccSat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpSUDotAccSat: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {39}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpTypeCooperativeMatrixKHR: + { + const static OperandKind operandTypes[] = {{44}, {47}, {46}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLoadKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixStoreKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixMulAddKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {40}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLengthKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpTypeRayQueryKHR: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpRayQueryInitializeKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpRayQueryTerminateKHR: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpRayQueryGenerateIntersectionKHR: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpRayQueryConfirmIntersectionKHR: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpRayQueryProceedKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionTypeKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpImageSampleWeightedQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageBoxFilterQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpImageBlockMatchSSDQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpImageBlockMatchSADQCOM: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpGroupIAddNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFAddNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMinNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMinNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMinNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMaxNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupUMaxNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupSMaxNonUniformAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpFragmentMaskFetchAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFragmentFetchAMD: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpReadClockKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 14, 14, 14, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpHitObjectRecordMissMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpHitObjectGetWorldToObjectNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetObjectToWorldNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetObjectRayDirectionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetObjectRayOriginNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectTraceRayMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpHitObjectGetShaderRecordBufferHandleNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetShaderBindingTableRecordIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectRecordEmptyNV: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpHitObjectTraceRayNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpHitObjectRecordMissNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpHitObjectExecuteShaderNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpHitObjectGetCurrentTimeNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetAttributesNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpHitObjectGetHitKindNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetPrimitiveIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetGeometryIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetInstanceIdNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetInstanceCustomIndexNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetWorldRayDirectionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetWorldRayOriginNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetRayTMaxNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectGetRayTMinNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectIsEmptyNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectIsHitNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpHitObjectIsMissNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpReorderThreadWithHitObjectNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 3, 3, operandTypes}; + return true; + } + case SpvOpReorderThreadWithHintNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeHitObjectNV: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpImageSampleFootprintNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {0}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 7, 7, operandTypes}; + return true; + } + case SpvOpEmitMeshTasksEXT: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 4, 4, operandTypes}; + return true; + } + case SpvOpSetMeshOutputsEXT: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpGroupNonUniformPartitionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpWritePackedPrimitiveIndices4x8NV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpReportIntersectionNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIgnoreIntersectionNV: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpTerminateRayNV: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpTraceNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 11, 11, 11, operandTypes}; + return true; + } + case SpvOpTraceMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpTraceRayMotionNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 12, 12, 12, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpTypeAccelerationStructureNV: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExecuteCallableNV: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeCooperativeMatrixNV: + { + const static OperandKind operandTypes[] = {{44}, {47}, {46}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLoadNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 6, 6, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixStoreNV: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {6}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 4, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixMulAddNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpCooperativeMatrixLengthNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpBeginInvocationInterlockEXT: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpEndInvocationInterlockEXT: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpDemoteToHelperInvocation: + { + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0, 0, nullptr}; + return true; + } + case SpvOpIsHelperInvocationEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpConvertUToImageNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToSamplerNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertImageToUNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertSamplerToUNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertUToSampledImageNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertSampledImageToUNV: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSamplerImageAddressingModeNV: + { + const static OperandKind operandTypes[] = {{48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleDownINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleUpINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupShuffleXorINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupBlockReadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupBlockWriteINTEL: + { + const static OperandKind operandTypes[] = {{47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupImageBlockReadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupImageBlockWriteINTEL: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupImageMediaBlockReadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupImageMediaBlockWriteINTEL: + { + const static OperandKind operandTypes[] = {{47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpUCountLeadingZerosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpUCountTrailingZerosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpAbsISubINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAbsUSubINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAddSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUAddSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAverageINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUAverageINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIAverageRoundedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUAverageRoundedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpISubSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUSubSatINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpIMul32x16INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpUMul32x16INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpConstantFunctionPointerINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpFunctionPointerCallINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 0xffff, 3, operandTypes}; + return true; + } + case SpvOpAsmTargetINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpAsmINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {49}, {49}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAsmCallINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 0xffff, 4, operandTypes}; + return true; + } + case SpvOpAtomicFMinEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAtomicFMaxEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpAssumeTrueKHR: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpExpectKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpDecorateString: + { + const static OperandKind operandTypes[] = {{47}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpMemberDecorateString: + { + const static OperandKind operandTypes[] = {{47}, {48}, {30}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpVmeImageINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpTypeVmeImageINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeAvcImePayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcRefPayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcSicPayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcMceResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcImeDualReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcRefResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpTypeAvcSicResultINTEL: + { + const static OperandKind operandTypes[] = {{44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImeResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeRefWindowSizeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeSetWeightedSadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMceResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetBorderReachedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcFmeInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpSubgroupAvcBmeInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMceResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicInitializeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConfigureSkcINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 13, 13, 13, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateIpeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMceResultINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpVariableLengthArrayINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpSaveMemoryINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpRestoreMemoryINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 1, 1, 1, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCastINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCastFromIntINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCastToIntINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 7, 7, 7, operandTypes}; + return true; + } + case SpvOpArbitraryFloatAddINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSubINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatMulINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatDivINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatGTINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatGEINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLTINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLEINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatEQINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpArbitraryFloatRecipINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatRSqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCbrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatHypotINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLogINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLog2INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLog10INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatLog1pINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExpINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExp2INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExp10INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatExpm1INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatSinPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatASinINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatASinPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatACosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatACosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatATanINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatATanPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 8, 8, 8, operandTypes}; + return true; + } + case SpvOpArbitraryFloatATan2INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatPowINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatPowRINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 10, 10, 10, operandTypes}; + return true; + } + case SpvOpArbitraryFloatPowNINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {48}, {47}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpLoopControlINTEL: + { + const static OperandKind operandTypes[] = {{48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpAliasDomainDeclINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 2, 2, operandTypes}; + return true; + } + case SpvOpAliasScopeDeclINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 2, 3, 3, operandTypes}; + return true; + } + case SpvOpAliasScopeListDeclINTEL: + { + const static OperandKind operandTypes[] = {{44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, 0, 1, 0xffff, 2, operandTypes}; + return true; + } + case SpvOpFixedSqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedRecipINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedRsqrtINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinCosINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedSinCosPiINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedLogINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpFixedExpINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}, {48}, {48}, {48}, {48}, {48}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 9, 9, 9, operandTypes}; + return true; + } + case SpvOpPtrCastToCrossWorkgroupINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpCrossWorkgroupCastToPtrINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpReadPipeBlockingINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpWritePipeBlockingINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpFPGARegINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetRayTMinKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetRayFlagsKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionTKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceIdKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionGeometryIndexKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionBarycentricsKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionFrontFaceKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetWorldRayDirectionKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetWorldRayOriginKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectToWorldKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpRayQueryGetIntersectionWorldToObjectKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 4, 4, 4, operandTypes}; + return true; + } + case SpvOpAtomicFAddEXT: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}, {46}, {45}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 6, 6, 6, operandTypes}; + return true; + } + case SpvOpTypeBufferSurfaceINTEL: + { + const static OperandKind operandTypes[] = {{44}, {28}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, 0, 2, 2, 2, operandTypes}; + return true; + } + case SpvOpTypeStructContinuedINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::TypeDeclaration, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpConstantCompositeContinuedINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpSpecConstantCompositeContinuedINTEL: + { + const static OperandKind operandTypes[] = {{47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::ConstantCreation, -1, -1, 0, 0xffff, 1, operandTypes}; + return true; + } + case SpvOpConvertFToBF16INTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpConvertBF16ToFINTEL: + { + const static OperandKind operandTypes[] = {{43}, {44}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpControlBarrierArriveINTEL: + { + const static OperandKind operandTypes[] = {{46}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpControlBarrierWaitINTEL: + { + const static OperandKind operandTypes[] = {{46}, {46}, {45}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, -1, -1, 3, 3, 3, operandTypes}; + return true; + } + case SpvOpGroupIMulKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupFMulKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupBitwiseAndKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupBitwiseOrKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupBitwiseXorKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupLogicalAndKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupLogicalOrKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + case SpvOpGroupLogicalXorKHR: + { + const static OperandKind operandTypes[] = {{43}, {44}, {46}, {33}, {47}}; + v = {SPIRVCoreGrammarInfo::OpInfo::Other, 0, 1, 5, 5, 5, operandTypes}; + return true; + } + default: return false; + } +} + +static bool getOpName(const SpvOp& k, UnownedStringSlice& v) +{ + switch(k) + { + case SpvOpNop: + { + v = UnownedStringSlice{"OpNop"}; + return true; + } + case SpvOpUndef: + { + v = UnownedStringSlice{"OpUndef"}; + return true; + } + case SpvOpSourceContinued: + { + v = UnownedStringSlice{"OpSourceContinued"}; + return true; + } + case SpvOpSource: + { + v = UnownedStringSlice{"OpSource"}; + return true; + } + case SpvOpSourceExtension: + { + v = UnownedStringSlice{"OpSourceExtension"}; + return true; + } + case SpvOpName: + { + v = UnownedStringSlice{"OpName"}; + return true; + } + case SpvOpMemberName: + { + v = UnownedStringSlice{"OpMemberName"}; + return true; + } + case SpvOpString: + { + v = UnownedStringSlice{"OpString"}; + return true; + } + case SpvOpLine: + { + v = UnownedStringSlice{"OpLine"}; + return true; + } + case SpvOpExtension: + { + v = UnownedStringSlice{"OpExtension"}; + return true; + } + case SpvOpExtInstImport: + { + v = UnownedStringSlice{"OpExtInstImport"}; + return true; + } + case SpvOpExtInst: + { + v = UnownedStringSlice{"OpExtInst"}; + return true; + } + case SpvOpMemoryModel: + { + v = UnownedStringSlice{"OpMemoryModel"}; + return true; + } + case SpvOpEntryPoint: + { + v = UnownedStringSlice{"OpEntryPoint"}; + return true; + } + case SpvOpExecutionMode: + { + v = UnownedStringSlice{"OpExecutionMode"}; + return true; + } + case SpvOpCapability: + { + v = UnownedStringSlice{"OpCapability"}; + return true; + } + case SpvOpTypeVoid: + { + v = UnownedStringSlice{"OpTypeVoid"}; + return true; + } + case SpvOpTypeBool: + { + v = UnownedStringSlice{"OpTypeBool"}; + return true; + } + case SpvOpTypeInt: + { + v = UnownedStringSlice{"OpTypeInt"}; + return true; + } + case SpvOpTypeFloat: + { + v = UnownedStringSlice{"OpTypeFloat"}; + return true; + } + case SpvOpTypeVector: + { + v = UnownedStringSlice{"OpTypeVector"}; + return true; + } + case SpvOpTypeMatrix: + { + v = UnownedStringSlice{"OpTypeMatrix"}; + return true; + } + case SpvOpTypeImage: + { + v = UnownedStringSlice{"OpTypeImage"}; + return true; + } + case SpvOpTypeSampler: + { + v = UnownedStringSlice{"OpTypeSampler"}; + return true; + } + case SpvOpTypeSampledImage: + { + v = UnownedStringSlice{"OpTypeSampledImage"}; + return true; + } + case SpvOpTypeArray: + { + v = UnownedStringSlice{"OpTypeArray"}; + return true; + } + case SpvOpTypeRuntimeArray: + { + v = UnownedStringSlice{"OpTypeRuntimeArray"}; + return true; + } + case SpvOpTypeStruct: + { + v = UnownedStringSlice{"OpTypeStruct"}; + return true; + } + case SpvOpTypeOpaque: + { + v = UnownedStringSlice{"OpTypeOpaque"}; + return true; + } + case SpvOpTypePointer: + { + v = UnownedStringSlice{"OpTypePointer"}; + return true; + } + case SpvOpTypeFunction: + { + v = UnownedStringSlice{"OpTypeFunction"}; + return true; + } + case SpvOpTypeEvent: + { + v = UnownedStringSlice{"OpTypeEvent"}; + return true; + } + case SpvOpTypeDeviceEvent: + { + v = UnownedStringSlice{"OpTypeDeviceEvent"}; + return true; + } + case SpvOpTypeReserveId: + { + v = UnownedStringSlice{"OpTypeReserveId"}; + return true; + } + case SpvOpTypeQueue: + { + v = UnownedStringSlice{"OpTypeQueue"}; + return true; + } + case SpvOpTypePipe: + { + v = UnownedStringSlice{"OpTypePipe"}; + return true; + } + case SpvOpTypeForwardPointer: + { + v = UnownedStringSlice{"OpTypeForwardPointer"}; + return true; + } + case SpvOpConstantTrue: + { + v = UnownedStringSlice{"OpConstantTrue"}; + return true; + } + case SpvOpConstantFalse: + { + v = UnownedStringSlice{"OpConstantFalse"}; + return true; + } + case SpvOpConstant: + { + v = UnownedStringSlice{"OpConstant"}; + return true; + } + case SpvOpConstantComposite: + { + v = UnownedStringSlice{"OpConstantComposite"}; + return true; + } + case SpvOpConstantSampler: + { + v = UnownedStringSlice{"OpConstantSampler"}; + return true; + } + case SpvOpConstantNull: + { + v = UnownedStringSlice{"OpConstantNull"}; + return true; + } + case SpvOpSpecConstantTrue: + { + v = UnownedStringSlice{"OpSpecConstantTrue"}; + return true; + } + case SpvOpSpecConstantFalse: + { + v = UnownedStringSlice{"OpSpecConstantFalse"}; + return true; + } + case SpvOpSpecConstant: + { + v = UnownedStringSlice{"OpSpecConstant"}; + return true; + } + case SpvOpSpecConstantComposite: + { + v = UnownedStringSlice{"OpSpecConstantComposite"}; + return true; + } + case SpvOpSpecConstantOp: + { + v = UnownedStringSlice{"OpSpecConstantOp"}; + return true; + } + case SpvOpFunction: + { + v = UnownedStringSlice{"OpFunction"}; + return true; + } + case SpvOpFunctionParameter: + { + v = UnownedStringSlice{"OpFunctionParameter"}; + return true; + } + case SpvOpFunctionEnd: + { + v = UnownedStringSlice{"OpFunctionEnd"}; + return true; + } + case SpvOpFunctionCall: + { + v = UnownedStringSlice{"OpFunctionCall"}; + return true; + } + case SpvOpVariable: + { + v = UnownedStringSlice{"OpVariable"}; + return true; + } + case SpvOpImageTexelPointer: + { + v = UnownedStringSlice{"OpImageTexelPointer"}; + return true; + } + case SpvOpLoad: + { + v = UnownedStringSlice{"OpLoad"}; + return true; + } + case SpvOpStore: + { + v = UnownedStringSlice{"OpStore"}; + return true; + } + case SpvOpCopyMemory: + { + v = UnownedStringSlice{"OpCopyMemory"}; + return true; + } + case SpvOpCopyMemorySized: + { + v = UnownedStringSlice{"OpCopyMemorySized"}; + return true; + } + case SpvOpAccessChain: + { + v = UnownedStringSlice{"OpAccessChain"}; + return true; + } + case SpvOpInBoundsAccessChain: + { + v = UnownedStringSlice{"OpInBoundsAccessChain"}; + return true; + } + case SpvOpPtrAccessChain: + { + v = UnownedStringSlice{"OpPtrAccessChain"}; + return true; + } + case SpvOpArrayLength: + { + v = UnownedStringSlice{"OpArrayLength"}; + return true; + } + case SpvOpGenericPtrMemSemantics: + { + v = UnownedStringSlice{"OpGenericPtrMemSemantics"}; + return true; + } + case SpvOpInBoundsPtrAccessChain: + { + v = UnownedStringSlice{"OpInBoundsPtrAccessChain"}; + return true; + } + case SpvOpDecorate: + { + v = UnownedStringSlice{"OpDecorate"}; + return true; + } + case SpvOpMemberDecorate: + { + v = UnownedStringSlice{"OpMemberDecorate"}; + return true; + } + case SpvOpDecorationGroup: + { + v = UnownedStringSlice{"OpDecorationGroup"}; + return true; + } + case SpvOpGroupDecorate: + { + v = UnownedStringSlice{"OpGroupDecorate"}; + return true; + } + case SpvOpGroupMemberDecorate: + { + v = UnownedStringSlice{"OpGroupMemberDecorate"}; + return true; + } + case SpvOpVectorExtractDynamic: + { + v = UnownedStringSlice{"OpVectorExtractDynamic"}; + return true; + } + case SpvOpVectorInsertDynamic: + { + v = UnownedStringSlice{"OpVectorInsertDynamic"}; + return true; + } + case SpvOpVectorShuffle: + { + v = UnownedStringSlice{"OpVectorShuffle"}; + return true; + } + case SpvOpCompositeConstruct: + { + v = UnownedStringSlice{"OpCompositeConstruct"}; + return true; + } + case SpvOpCompositeExtract: + { + v = UnownedStringSlice{"OpCompositeExtract"}; + return true; + } + case SpvOpCompositeInsert: + { + v = UnownedStringSlice{"OpCompositeInsert"}; + return true; + } + case SpvOpCopyObject: + { + v = UnownedStringSlice{"OpCopyObject"}; + return true; + } + case SpvOpTranspose: + { + v = UnownedStringSlice{"OpTranspose"}; + return true; + } + case SpvOpSampledImage: + { + v = UnownedStringSlice{"OpSampledImage"}; + return true; + } + case SpvOpImageSampleImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleImplicitLod"}; + return true; + } + case SpvOpImageSampleExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleExplicitLod"}; + return true; + } + case SpvOpImageSampleDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleDrefImplicitLod"}; + return true; + } + case SpvOpImageSampleDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleDrefExplicitLod"}; + return true; + } + case SpvOpImageSampleProjImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjImplicitLod"}; + return true; + } + case SpvOpImageSampleProjExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjExplicitLod"}; + return true; + } + case SpvOpImageSampleProjDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjDrefImplicitLod"}; + return true; + } + case SpvOpImageSampleProjDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSampleProjDrefExplicitLod"}; + return true; + } + case SpvOpImageFetch: + { + v = UnownedStringSlice{"OpImageFetch"}; + return true; + } + case SpvOpImageGather: + { + v = UnownedStringSlice{"OpImageGather"}; + return true; + } + case SpvOpImageDrefGather: + { + v = UnownedStringSlice{"OpImageDrefGather"}; + return true; + } + case SpvOpImageRead: + { + v = UnownedStringSlice{"OpImageRead"}; + return true; + } + case SpvOpImageWrite: + { + v = UnownedStringSlice{"OpImageWrite"}; + return true; + } + case SpvOpImage: + { + v = UnownedStringSlice{"OpImage"}; + return true; + } + case SpvOpImageQueryFormat: + { + v = UnownedStringSlice{"OpImageQueryFormat"}; + return true; + } + case SpvOpImageQueryOrder: + { + v = UnownedStringSlice{"OpImageQueryOrder"}; + return true; + } + case SpvOpImageQuerySizeLod: + { + v = UnownedStringSlice{"OpImageQuerySizeLod"}; + return true; + } + case SpvOpImageQuerySize: + { + v = UnownedStringSlice{"OpImageQuerySize"}; + return true; + } + case SpvOpImageQueryLod: + { + v = UnownedStringSlice{"OpImageQueryLod"}; + return true; + } + case SpvOpImageQueryLevels: + { + v = UnownedStringSlice{"OpImageQueryLevels"}; + return true; + } + case SpvOpImageQuerySamples: + { + v = UnownedStringSlice{"OpImageQuerySamples"}; + return true; + } + case SpvOpConvertFToU: + { + v = UnownedStringSlice{"OpConvertFToU"}; + return true; + } + case SpvOpConvertFToS: + { + v = UnownedStringSlice{"OpConvertFToS"}; + return true; + } + case SpvOpConvertSToF: + { + v = UnownedStringSlice{"OpConvertSToF"}; + return true; + } + case SpvOpConvertUToF: + { + v = UnownedStringSlice{"OpConvertUToF"}; + return true; + } + case SpvOpUConvert: + { + v = UnownedStringSlice{"OpUConvert"}; + return true; + } + case SpvOpSConvert: + { + v = UnownedStringSlice{"OpSConvert"}; + return true; + } + case SpvOpFConvert: + { + v = UnownedStringSlice{"OpFConvert"}; + return true; + } + case SpvOpQuantizeToF16: + { + v = UnownedStringSlice{"OpQuantizeToF16"}; + return true; + } + case SpvOpConvertPtrToU: + { + v = UnownedStringSlice{"OpConvertPtrToU"}; + return true; + } + case SpvOpSatConvertSToU: + { + v = UnownedStringSlice{"OpSatConvertSToU"}; + return true; + } + case SpvOpSatConvertUToS: + { + v = UnownedStringSlice{"OpSatConvertUToS"}; + return true; + } + case SpvOpConvertUToPtr: + { + v = UnownedStringSlice{"OpConvertUToPtr"}; + return true; + } + case SpvOpPtrCastToGeneric: + { + v = UnownedStringSlice{"OpPtrCastToGeneric"}; + return true; + } + case SpvOpGenericCastToPtr: + { + v = UnownedStringSlice{"OpGenericCastToPtr"}; + return true; + } + case SpvOpGenericCastToPtrExplicit: + { + v = UnownedStringSlice{"OpGenericCastToPtrExplicit"}; + return true; + } + case SpvOpBitcast: + { + v = UnownedStringSlice{"OpBitcast"}; + return true; + } + case SpvOpSNegate: + { + v = UnownedStringSlice{"OpSNegate"}; + return true; + } + case SpvOpFNegate: + { + v = UnownedStringSlice{"OpFNegate"}; + return true; + } + case SpvOpIAdd: + { + v = UnownedStringSlice{"OpIAdd"}; + return true; + } + case SpvOpFAdd: + { + v = UnownedStringSlice{"OpFAdd"}; + return true; + } + case SpvOpISub: + { + v = UnownedStringSlice{"OpISub"}; + return true; + } + case SpvOpFSub: + { + v = UnownedStringSlice{"OpFSub"}; + return true; + } + case SpvOpIMul: + { + v = UnownedStringSlice{"OpIMul"}; + return true; + } + case SpvOpFMul: + { + v = UnownedStringSlice{"OpFMul"}; + return true; + } + case SpvOpUDiv: + { + v = UnownedStringSlice{"OpUDiv"}; + return true; + } + case SpvOpSDiv: + { + v = UnownedStringSlice{"OpSDiv"}; + return true; + } + case SpvOpFDiv: + { + v = UnownedStringSlice{"OpFDiv"}; + return true; + } + case SpvOpUMod: + { + v = UnownedStringSlice{"OpUMod"}; + return true; + } + case SpvOpSRem: + { + v = UnownedStringSlice{"OpSRem"}; + return true; + } + case SpvOpSMod: + { + v = UnownedStringSlice{"OpSMod"}; + return true; + } + case SpvOpFRem: + { + v = UnownedStringSlice{"OpFRem"}; + return true; + } + case SpvOpFMod: + { + v = UnownedStringSlice{"OpFMod"}; + return true; + } + case SpvOpVectorTimesScalar: + { + v = UnownedStringSlice{"OpVectorTimesScalar"}; + return true; + } + case SpvOpMatrixTimesScalar: + { + v = UnownedStringSlice{"OpMatrixTimesScalar"}; + return true; + } + case SpvOpVectorTimesMatrix: + { + v = UnownedStringSlice{"OpVectorTimesMatrix"}; + return true; + } + case SpvOpMatrixTimesVector: + { + v = UnownedStringSlice{"OpMatrixTimesVector"}; + return true; + } + case SpvOpMatrixTimesMatrix: + { + v = UnownedStringSlice{"OpMatrixTimesMatrix"}; + return true; + } + case SpvOpOuterProduct: + { + v = UnownedStringSlice{"OpOuterProduct"}; + return true; + } + case SpvOpDot: + { + v = UnownedStringSlice{"OpDot"}; + return true; + } + case SpvOpIAddCarry: + { + v = UnownedStringSlice{"OpIAddCarry"}; + return true; + } + case SpvOpISubBorrow: + { + v = UnownedStringSlice{"OpISubBorrow"}; + return true; + } + case SpvOpUMulExtended: + { + v = UnownedStringSlice{"OpUMulExtended"}; + return true; + } + case SpvOpSMulExtended: + { + v = UnownedStringSlice{"OpSMulExtended"}; + return true; + } + case SpvOpAny: + { + v = UnownedStringSlice{"OpAny"}; + return true; + } + case SpvOpAll: + { + v = UnownedStringSlice{"OpAll"}; + return true; + } + case SpvOpIsNan: + { + v = UnownedStringSlice{"OpIsNan"}; + return true; + } + case SpvOpIsInf: + { + v = UnownedStringSlice{"OpIsInf"}; + return true; + } + case SpvOpIsFinite: + { + v = UnownedStringSlice{"OpIsFinite"}; + return true; + } + case SpvOpIsNormal: + { + v = UnownedStringSlice{"OpIsNormal"}; + return true; + } + case SpvOpSignBitSet: + { + v = UnownedStringSlice{"OpSignBitSet"}; + return true; + } + case SpvOpLessOrGreater: + { + v = UnownedStringSlice{"OpLessOrGreater"}; + return true; + } + case SpvOpOrdered: + { + v = UnownedStringSlice{"OpOrdered"}; + return true; + } + case SpvOpUnordered: + { + v = UnownedStringSlice{"OpUnordered"}; + return true; + } + case SpvOpLogicalEqual: + { + v = UnownedStringSlice{"OpLogicalEqual"}; + return true; + } + case SpvOpLogicalNotEqual: + { + v = UnownedStringSlice{"OpLogicalNotEqual"}; + return true; + } + case SpvOpLogicalOr: + { + v = UnownedStringSlice{"OpLogicalOr"}; + return true; + } + case SpvOpLogicalAnd: + { + v = UnownedStringSlice{"OpLogicalAnd"}; + return true; + } + case SpvOpLogicalNot: + { + v = UnownedStringSlice{"OpLogicalNot"}; + return true; + } + case SpvOpSelect: + { + v = UnownedStringSlice{"OpSelect"}; + return true; + } + case SpvOpIEqual: + { + v = UnownedStringSlice{"OpIEqual"}; + return true; + } + case SpvOpINotEqual: + { + v = UnownedStringSlice{"OpINotEqual"}; + return true; + } + case SpvOpUGreaterThan: + { + v = UnownedStringSlice{"OpUGreaterThan"}; + return true; + } + case SpvOpSGreaterThan: + { + v = UnownedStringSlice{"OpSGreaterThan"}; + return true; + } + case SpvOpUGreaterThanEqual: + { + v = UnownedStringSlice{"OpUGreaterThanEqual"}; + return true; + } + case SpvOpSGreaterThanEqual: + { + v = UnownedStringSlice{"OpSGreaterThanEqual"}; + return true; + } + case SpvOpULessThan: + { + v = UnownedStringSlice{"OpULessThan"}; + return true; + } + case SpvOpSLessThan: + { + v = UnownedStringSlice{"OpSLessThan"}; + return true; + } + case SpvOpULessThanEqual: + { + v = UnownedStringSlice{"OpULessThanEqual"}; + return true; + } + case SpvOpSLessThanEqual: + { + v = UnownedStringSlice{"OpSLessThanEqual"}; + return true; + } + case SpvOpFOrdEqual: + { + v = UnownedStringSlice{"OpFOrdEqual"}; + return true; + } + case SpvOpFUnordEqual: + { + v = UnownedStringSlice{"OpFUnordEqual"}; + return true; + } + case SpvOpFOrdNotEqual: + { + v = UnownedStringSlice{"OpFOrdNotEqual"}; + return true; + } + case SpvOpFUnordNotEqual: + { + v = UnownedStringSlice{"OpFUnordNotEqual"}; + return true; + } + case SpvOpFOrdLessThan: + { + v = UnownedStringSlice{"OpFOrdLessThan"}; + return true; + } + case SpvOpFUnordLessThan: + { + v = UnownedStringSlice{"OpFUnordLessThan"}; + return true; + } + case SpvOpFOrdGreaterThan: + { + v = UnownedStringSlice{"OpFOrdGreaterThan"}; + return true; + } + case SpvOpFUnordGreaterThan: + { + v = UnownedStringSlice{"OpFUnordGreaterThan"}; + return true; + } + case SpvOpFOrdLessThanEqual: + { + v = UnownedStringSlice{"OpFOrdLessThanEqual"}; + return true; + } + case SpvOpFUnordLessThanEqual: + { + v = UnownedStringSlice{"OpFUnordLessThanEqual"}; + return true; + } + case SpvOpFOrdGreaterThanEqual: + { + v = UnownedStringSlice{"OpFOrdGreaterThanEqual"}; + return true; + } + case SpvOpFUnordGreaterThanEqual: + { + v = UnownedStringSlice{"OpFUnordGreaterThanEqual"}; + return true; + } + case SpvOpShiftRightLogical: + { + v = UnownedStringSlice{"OpShiftRightLogical"}; + return true; + } + case SpvOpShiftRightArithmetic: + { + v = UnownedStringSlice{"OpShiftRightArithmetic"}; + return true; + } + case SpvOpShiftLeftLogical: + { + v = UnownedStringSlice{"OpShiftLeftLogical"}; + return true; + } + case SpvOpBitwiseOr: + { + v = UnownedStringSlice{"OpBitwiseOr"}; + return true; + } + case SpvOpBitwiseXor: + { + v = UnownedStringSlice{"OpBitwiseXor"}; + return true; + } + case SpvOpBitwiseAnd: + { + v = UnownedStringSlice{"OpBitwiseAnd"}; + return true; + } + case SpvOpNot: + { + v = UnownedStringSlice{"OpNot"}; + return true; + } + case SpvOpBitFieldInsert: + { + v = UnownedStringSlice{"OpBitFieldInsert"}; + return true; + } + case SpvOpBitFieldSExtract: + { + v = UnownedStringSlice{"OpBitFieldSExtract"}; + return true; + } + case SpvOpBitFieldUExtract: + { + v = UnownedStringSlice{"OpBitFieldUExtract"}; + return true; + } + case SpvOpBitReverse: + { + v = UnownedStringSlice{"OpBitReverse"}; + return true; + } + case SpvOpBitCount: + { + v = UnownedStringSlice{"OpBitCount"}; + return true; + } + case SpvOpDPdx: + { + v = UnownedStringSlice{"OpDPdx"}; + return true; + } + case SpvOpDPdy: + { + v = UnownedStringSlice{"OpDPdy"}; + return true; + } + case SpvOpFwidth: + { + v = UnownedStringSlice{"OpFwidth"}; + return true; + } + case SpvOpDPdxFine: + { + v = UnownedStringSlice{"OpDPdxFine"}; + return true; + } + case SpvOpDPdyFine: + { + v = UnownedStringSlice{"OpDPdyFine"}; + return true; + } + case SpvOpFwidthFine: + { + v = UnownedStringSlice{"OpFwidthFine"}; + return true; + } + case SpvOpDPdxCoarse: + { + v = UnownedStringSlice{"OpDPdxCoarse"}; + return true; + } + case SpvOpDPdyCoarse: + { + v = UnownedStringSlice{"OpDPdyCoarse"}; + return true; + } + case SpvOpFwidthCoarse: + { + v = UnownedStringSlice{"OpFwidthCoarse"}; + return true; + } + case SpvOpEmitVertex: + { + v = UnownedStringSlice{"OpEmitVertex"}; + return true; + } + case SpvOpEndPrimitive: + { + v = UnownedStringSlice{"OpEndPrimitive"}; + return true; + } + case SpvOpEmitStreamVertex: + { + v = UnownedStringSlice{"OpEmitStreamVertex"}; + return true; + } + case SpvOpEndStreamPrimitive: + { + v = UnownedStringSlice{"OpEndStreamPrimitive"}; + return true; + } + case SpvOpControlBarrier: + { + v = UnownedStringSlice{"OpControlBarrier"}; + return true; + } + case SpvOpMemoryBarrier: + { + v = UnownedStringSlice{"OpMemoryBarrier"}; + return true; + } + case SpvOpAtomicLoad: + { + v = UnownedStringSlice{"OpAtomicLoad"}; + return true; + } + case SpvOpAtomicStore: + { + v = UnownedStringSlice{"OpAtomicStore"}; + return true; + } + case SpvOpAtomicExchange: + { + v = UnownedStringSlice{"OpAtomicExchange"}; + return true; + } + case SpvOpAtomicCompareExchange: + { + v = UnownedStringSlice{"OpAtomicCompareExchange"}; + return true; + } + case SpvOpAtomicCompareExchangeWeak: + { + v = UnownedStringSlice{"OpAtomicCompareExchangeWeak"}; + return true; + } + case SpvOpAtomicIIncrement: + { + v = UnownedStringSlice{"OpAtomicIIncrement"}; + return true; + } + case SpvOpAtomicIDecrement: + { + v = UnownedStringSlice{"OpAtomicIDecrement"}; + return true; + } + case SpvOpAtomicIAdd: + { + v = UnownedStringSlice{"OpAtomicIAdd"}; + return true; + } + case SpvOpAtomicISub: + { + v = UnownedStringSlice{"OpAtomicISub"}; + return true; + } + case SpvOpAtomicSMin: + { + v = UnownedStringSlice{"OpAtomicSMin"}; + return true; + } + case SpvOpAtomicUMin: + { + v = UnownedStringSlice{"OpAtomicUMin"}; + return true; + } + case SpvOpAtomicSMax: + { + v = UnownedStringSlice{"OpAtomicSMax"}; + return true; + } + case SpvOpAtomicUMax: + { + v = UnownedStringSlice{"OpAtomicUMax"}; + return true; + } + case SpvOpAtomicAnd: + { + v = UnownedStringSlice{"OpAtomicAnd"}; + return true; + } + case SpvOpAtomicOr: + { + v = UnownedStringSlice{"OpAtomicOr"}; + return true; + } + case SpvOpAtomicXor: + { + v = UnownedStringSlice{"OpAtomicXor"}; + return true; + } + case SpvOpPhi: + { + v = UnownedStringSlice{"OpPhi"}; + return true; + } + case SpvOpLoopMerge: + { + v = UnownedStringSlice{"OpLoopMerge"}; + return true; + } + case SpvOpSelectionMerge: + { + v = UnownedStringSlice{"OpSelectionMerge"}; + return true; + } + case SpvOpLabel: + { + v = UnownedStringSlice{"OpLabel"}; + return true; + } + case SpvOpBranch: + { + v = UnownedStringSlice{"OpBranch"}; + return true; + } + case SpvOpBranchConditional: + { + v = UnownedStringSlice{"OpBranchConditional"}; + return true; + } + case SpvOpSwitch: + { + v = UnownedStringSlice{"OpSwitch"}; + return true; + } + case SpvOpKill: + { + v = UnownedStringSlice{"OpKill"}; + return true; + } + case SpvOpReturn: + { + v = UnownedStringSlice{"OpReturn"}; + return true; + } + case SpvOpReturnValue: + { + v = UnownedStringSlice{"OpReturnValue"}; + return true; + } + case SpvOpUnreachable: + { + v = UnownedStringSlice{"OpUnreachable"}; + return true; + } + case SpvOpLifetimeStart: + { + v = UnownedStringSlice{"OpLifetimeStart"}; + return true; + } + case SpvOpLifetimeStop: + { + v = UnownedStringSlice{"OpLifetimeStop"}; + return true; + } + case SpvOpGroupAsyncCopy: + { + v = UnownedStringSlice{"OpGroupAsyncCopy"}; + return true; + } + case SpvOpGroupWaitEvents: + { + v = UnownedStringSlice{"OpGroupWaitEvents"}; + return true; + } + case SpvOpGroupAll: + { + v = UnownedStringSlice{"OpGroupAll"}; + return true; + } + case SpvOpGroupAny: + { + v = UnownedStringSlice{"OpGroupAny"}; + return true; + } + case SpvOpGroupBroadcast: + { + v = UnownedStringSlice{"OpGroupBroadcast"}; + return true; + } + case SpvOpGroupIAdd: + { + v = UnownedStringSlice{"OpGroupIAdd"}; + return true; + } + case SpvOpGroupFAdd: + { + v = UnownedStringSlice{"OpGroupFAdd"}; + return true; + } + case SpvOpGroupFMin: + { + v = UnownedStringSlice{"OpGroupFMin"}; + return true; + } + case SpvOpGroupUMin: + { + v = UnownedStringSlice{"OpGroupUMin"}; + return true; + } + case SpvOpGroupSMin: + { + v = UnownedStringSlice{"OpGroupSMin"}; + return true; + } + case SpvOpGroupFMax: + { + v = UnownedStringSlice{"OpGroupFMax"}; + return true; + } + case SpvOpGroupUMax: + { + v = UnownedStringSlice{"OpGroupUMax"}; + return true; + } + case SpvOpGroupSMax: + { + v = UnownedStringSlice{"OpGroupSMax"}; + return true; + } + case SpvOpReadPipe: + { + v = UnownedStringSlice{"OpReadPipe"}; + return true; + } + case SpvOpWritePipe: + { + v = UnownedStringSlice{"OpWritePipe"}; + return true; + } + case SpvOpReservedReadPipe: + { + v = UnownedStringSlice{"OpReservedReadPipe"}; + return true; + } + case SpvOpReservedWritePipe: + { + v = UnownedStringSlice{"OpReservedWritePipe"}; + return true; + } + case SpvOpReserveReadPipePackets: + { + v = UnownedStringSlice{"OpReserveReadPipePackets"}; + return true; + } + case SpvOpReserveWritePipePackets: + { + v = UnownedStringSlice{"OpReserveWritePipePackets"}; + return true; + } + case SpvOpCommitReadPipe: + { + v = UnownedStringSlice{"OpCommitReadPipe"}; + return true; + } + case SpvOpCommitWritePipe: + { + v = UnownedStringSlice{"OpCommitWritePipe"}; + return true; + } + case SpvOpIsValidReserveId: + { + v = UnownedStringSlice{"OpIsValidReserveId"}; + return true; + } + case SpvOpGetNumPipePackets: + { + v = UnownedStringSlice{"OpGetNumPipePackets"}; + return true; + } + case SpvOpGetMaxPipePackets: + { + v = UnownedStringSlice{"OpGetMaxPipePackets"}; + return true; + } + case SpvOpGroupReserveReadPipePackets: + { + v = UnownedStringSlice{"OpGroupReserveReadPipePackets"}; + return true; + } + case SpvOpGroupReserveWritePipePackets: + { + v = UnownedStringSlice{"OpGroupReserveWritePipePackets"}; + return true; + } + case SpvOpGroupCommitReadPipe: + { + v = UnownedStringSlice{"OpGroupCommitReadPipe"}; + return true; + } + case SpvOpGroupCommitWritePipe: + { + v = UnownedStringSlice{"OpGroupCommitWritePipe"}; + return true; + } + case SpvOpEnqueueMarker: + { + v = UnownedStringSlice{"OpEnqueueMarker"}; + return true; + } + case SpvOpEnqueueKernel: + { + v = UnownedStringSlice{"OpEnqueueKernel"}; + return true; + } + case SpvOpGetKernelNDrangeSubGroupCount: + { + v = UnownedStringSlice{"OpGetKernelNDrangeSubGroupCount"}; + return true; + } + case SpvOpGetKernelNDrangeMaxSubGroupSize: + { + v = UnownedStringSlice{"OpGetKernelNDrangeMaxSubGroupSize"}; + return true; + } + case SpvOpGetKernelWorkGroupSize: + { + v = UnownedStringSlice{"OpGetKernelWorkGroupSize"}; + return true; + } + case SpvOpGetKernelPreferredWorkGroupSizeMultiple: + { + v = UnownedStringSlice{"OpGetKernelPreferredWorkGroupSizeMultiple"}; + return true; + } + case SpvOpRetainEvent: + { + v = UnownedStringSlice{"OpRetainEvent"}; + return true; + } + case SpvOpReleaseEvent: + { + v = UnownedStringSlice{"OpReleaseEvent"}; + return true; + } + case SpvOpCreateUserEvent: + { + v = UnownedStringSlice{"OpCreateUserEvent"}; + return true; + } + case SpvOpIsValidEvent: + { + v = UnownedStringSlice{"OpIsValidEvent"}; + return true; + } + case SpvOpSetUserEventStatus: + { + v = UnownedStringSlice{"OpSetUserEventStatus"}; + return true; + } + case SpvOpCaptureEventProfilingInfo: + { + v = UnownedStringSlice{"OpCaptureEventProfilingInfo"}; + return true; + } + case SpvOpGetDefaultQueue: + { + v = UnownedStringSlice{"OpGetDefaultQueue"}; + return true; + } + case SpvOpBuildNDRange: + { + v = UnownedStringSlice{"OpBuildNDRange"}; + return true; + } + case SpvOpImageSparseSampleImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleExplicitLod"}; + return true; + } + case SpvOpImageSparseSampleDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleDrefImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleDrefExplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjExplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjDrefImplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjDrefImplicitLod"}; + return true; + } + case SpvOpImageSparseSampleProjDrefExplicitLod: + { + v = UnownedStringSlice{"OpImageSparseSampleProjDrefExplicitLod"}; + return true; + } + case SpvOpImageSparseFetch: + { + v = UnownedStringSlice{"OpImageSparseFetch"}; + return true; + } + case SpvOpImageSparseGather: + { + v = UnownedStringSlice{"OpImageSparseGather"}; + return true; + } + case SpvOpImageSparseDrefGather: + { + v = UnownedStringSlice{"OpImageSparseDrefGather"}; + return true; + } + case SpvOpImageSparseTexelsResident: + { + v = UnownedStringSlice{"OpImageSparseTexelsResident"}; + return true; + } + case SpvOpNoLine: + { + v = UnownedStringSlice{"OpNoLine"}; + return true; + } + case SpvOpAtomicFlagTestAndSet: + { + v = UnownedStringSlice{"OpAtomicFlagTestAndSet"}; + return true; + } + case SpvOpAtomicFlagClear: + { + v = UnownedStringSlice{"OpAtomicFlagClear"}; + return true; + } + case SpvOpImageSparseRead: + { + v = UnownedStringSlice{"OpImageSparseRead"}; + return true; + } + case SpvOpSizeOf: + { + v = UnownedStringSlice{"OpSizeOf"}; + return true; + } + case SpvOpTypePipeStorage: + { + v = UnownedStringSlice{"OpTypePipeStorage"}; + return true; + } + case SpvOpConstantPipeStorage: + { + v = UnownedStringSlice{"OpConstantPipeStorage"}; + return true; + } + case SpvOpCreatePipeFromPipeStorage: + { + v = UnownedStringSlice{"OpCreatePipeFromPipeStorage"}; + return true; + } + case SpvOpGetKernelLocalSizeForSubgroupCount: + { + v = UnownedStringSlice{"OpGetKernelLocalSizeForSubgroupCount"}; + return true; + } + case SpvOpGetKernelMaxNumSubgroups: + { + v = UnownedStringSlice{"OpGetKernelMaxNumSubgroups"}; + return true; + } + case SpvOpTypeNamedBarrier: + { + v = UnownedStringSlice{"OpTypeNamedBarrier"}; + return true; + } + case SpvOpNamedBarrierInitialize: + { + v = UnownedStringSlice{"OpNamedBarrierInitialize"}; + return true; + } + case SpvOpMemoryNamedBarrier: + { + v = UnownedStringSlice{"OpMemoryNamedBarrier"}; + return true; + } + case SpvOpModuleProcessed: + { + v = UnownedStringSlice{"OpModuleProcessed"}; + return true; + } + case SpvOpExecutionModeId: + { + v = UnownedStringSlice{"OpExecutionModeId"}; + return true; + } + case SpvOpDecorateId: + { + v = UnownedStringSlice{"OpDecorateId"}; + return true; + } + case SpvOpGroupNonUniformElect: + { + v = UnownedStringSlice{"OpGroupNonUniformElect"}; + return true; + } + case SpvOpGroupNonUniformAll: + { + v = UnownedStringSlice{"OpGroupNonUniformAll"}; + return true; + } + case SpvOpGroupNonUniformAny: + { + v = UnownedStringSlice{"OpGroupNonUniformAny"}; + return true; + } + case SpvOpGroupNonUniformAllEqual: + { + v = UnownedStringSlice{"OpGroupNonUniformAllEqual"}; + return true; + } + case SpvOpGroupNonUniformBroadcast: + { + v = UnownedStringSlice{"OpGroupNonUniformBroadcast"}; + return true; + } + case SpvOpGroupNonUniformBroadcastFirst: + { + v = UnownedStringSlice{"OpGroupNonUniformBroadcastFirst"}; + return true; + } + case SpvOpGroupNonUniformBallot: + { + v = UnownedStringSlice{"OpGroupNonUniformBallot"}; + return true; + } + case SpvOpGroupNonUniformInverseBallot: + { + v = UnownedStringSlice{"OpGroupNonUniformInverseBallot"}; + return true; + } + case SpvOpGroupNonUniformBallotBitExtract: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotBitExtract"}; + return true; + } + case SpvOpGroupNonUniformBallotBitCount: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotBitCount"}; + return true; + } + case SpvOpGroupNonUniformBallotFindLSB: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotFindLSB"}; + return true; + } + case SpvOpGroupNonUniformBallotFindMSB: + { + v = UnownedStringSlice{"OpGroupNonUniformBallotFindMSB"}; + return true; + } + case SpvOpGroupNonUniformShuffle: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffle"}; + return true; + } + case SpvOpGroupNonUniformShuffleXor: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffleXor"}; + return true; + } + case SpvOpGroupNonUniformShuffleUp: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffleUp"}; + return true; + } + case SpvOpGroupNonUniformShuffleDown: + { + v = UnownedStringSlice{"OpGroupNonUniformShuffleDown"}; + return true; + } + case SpvOpGroupNonUniformIAdd: + { + v = UnownedStringSlice{"OpGroupNonUniformIAdd"}; + return true; + } + case SpvOpGroupNonUniformFAdd: + { + v = UnownedStringSlice{"OpGroupNonUniformFAdd"}; + return true; + } + case SpvOpGroupNonUniformIMul: + { + v = UnownedStringSlice{"OpGroupNonUniformIMul"}; + return true; + } + case SpvOpGroupNonUniformFMul: + { + v = UnownedStringSlice{"OpGroupNonUniformFMul"}; + return true; + } + case SpvOpGroupNonUniformSMin: + { + v = UnownedStringSlice{"OpGroupNonUniformSMin"}; + return true; + } + case SpvOpGroupNonUniformUMin: + { + v = UnownedStringSlice{"OpGroupNonUniformUMin"}; + return true; + } + case SpvOpGroupNonUniformFMin: + { + v = UnownedStringSlice{"OpGroupNonUniformFMin"}; + return true; + } + case SpvOpGroupNonUniformSMax: + { + v = UnownedStringSlice{"OpGroupNonUniformSMax"}; + return true; + } + case SpvOpGroupNonUniformUMax: + { + v = UnownedStringSlice{"OpGroupNonUniformUMax"}; + return true; + } + case SpvOpGroupNonUniformFMax: + { + v = UnownedStringSlice{"OpGroupNonUniformFMax"}; + return true; + } + case SpvOpGroupNonUniformBitwiseAnd: + { + v = UnownedStringSlice{"OpGroupNonUniformBitwiseAnd"}; + return true; + } + case SpvOpGroupNonUniformBitwiseOr: + { + v = UnownedStringSlice{"OpGroupNonUniformBitwiseOr"}; + return true; + } + case SpvOpGroupNonUniformBitwiseXor: + { + v = UnownedStringSlice{"OpGroupNonUniformBitwiseXor"}; + return true; + } + case SpvOpGroupNonUniformLogicalAnd: + { + v = UnownedStringSlice{"OpGroupNonUniformLogicalAnd"}; + return true; + } + case SpvOpGroupNonUniformLogicalOr: + { + v = UnownedStringSlice{"OpGroupNonUniformLogicalOr"}; + return true; + } + case SpvOpGroupNonUniformLogicalXor: + { + v = UnownedStringSlice{"OpGroupNonUniformLogicalXor"}; + return true; + } + case SpvOpGroupNonUniformQuadBroadcast: + { + v = UnownedStringSlice{"OpGroupNonUniformQuadBroadcast"}; + return true; + } + case SpvOpGroupNonUniformQuadSwap: + { + v = UnownedStringSlice{"OpGroupNonUniformQuadSwap"}; + return true; + } + case SpvOpCopyLogical: + { + v = UnownedStringSlice{"OpCopyLogical"}; + return true; + } + case SpvOpPtrEqual: + { + v = UnownedStringSlice{"OpPtrEqual"}; + return true; + } + case SpvOpPtrNotEqual: + { + v = UnownedStringSlice{"OpPtrNotEqual"}; + return true; + } + case SpvOpPtrDiff: + { + v = UnownedStringSlice{"OpPtrDiff"}; + return true; + } + case SpvOpColorAttachmentReadEXT: + { + v = UnownedStringSlice{"OpColorAttachmentReadEXT"}; + return true; + } + case SpvOpDepthAttachmentReadEXT: + { + v = UnownedStringSlice{"OpDepthAttachmentReadEXT"}; + return true; + } + case SpvOpStencilAttachmentReadEXT: + { + v = UnownedStringSlice{"OpStencilAttachmentReadEXT"}; + return true; + } + case SpvOpTerminateInvocation: + { + v = UnownedStringSlice{"OpTerminateInvocation"}; + return true; + } + case SpvOpSubgroupBallotKHR: + { + v = UnownedStringSlice{"OpSubgroupBallotKHR"}; + return true; + } + case SpvOpSubgroupFirstInvocationKHR: + { + v = UnownedStringSlice{"OpSubgroupFirstInvocationKHR"}; + return true; + } + case SpvOpSubgroupAllKHR: + { + v = UnownedStringSlice{"OpSubgroupAllKHR"}; + return true; + } + case SpvOpSubgroupAnyKHR: + { + v = UnownedStringSlice{"OpSubgroupAnyKHR"}; + return true; + } + case SpvOpSubgroupAllEqualKHR: + { + v = UnownedStringSlice{"OpSubgroupAllEqualKHR"}; + return true; + } + case SpvOpGroupNonUniformRotateKHR: + { + v = UnownedStringSlice{"OpGroupNonUniformRotateKHR"}; + return true; + } + case SpvOpSubgroupReadInvocationKHR: + { + v = UnownedStringSlice{"OpSubgroupReadInvocationKHR"}; + return true; + } + case SpvOpTraceRayKHR: + { + v = UnownedStringSlice{"OpTraceRayKHR"}; + return true; + } + case SpvOpExecuteCallableKHR: + { + v = UnownedStringSlice{"OpExecuteCallableKHR"}; + return true; + } + case SpvOpConvertUToAccelerationStructureKHR: + { + v = UnownedStringSlice{"OpConvertUToAccelerationStructureKHR"}; + return true; + } + case SpvOpIgnoreIntersectionKHR: + { + v = UnownedStringSlice{"OpIgnoreIntersectionKHR"}; + return true; + } + case SpvOpTerminateRayKHR: + { + v = UnownedStringSlice{"OpTerminateRayKHR"}; + return true; + } + case SpvOpSDot: + { + v = UnownedStringSlice{"OpSDot"}; + return true; + } + case SpvOpUDot: + { + v = UnownedStringSlice{"OpUDot"}; + return true; + } + case SpvOpSUDot: + { + v = UnownedStringSlice{"OpSUDot"}; + return true; + } + case SpvOpSDotAccSat: + { + v = UnownedStringSlice{"OpSDotAccSat"}; + return true; + } + case SpvOpUDotAccSat: + { + v = UnownedStringSlice{"OpUDotAccSat"}; + return true; + } + case SpvOpSUDotAccSat: + { + v = UnownedStringSlice{"OpSUDotAccSat"}; + return true; + } + case SpvOpTypeCooperativeMatrixKHR: + { + v = UnownedStringSlice{"OpTypeCooperativeMatrixKHR"}; + return true; + } + case SpvOpCooperativeMatrixLoadKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixLoadKHR"}; + return true; + } + case SpvOpCooperativeMatrixStoreKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixStoreKHR"}; + return true; + } + case SpvOpCooperativeMatrixMulAddKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixMulAddKHR"}; + return true; + } + case SpvOpCooperativeMatrixLengthKHR: + { + v = UnownedStringSlice{"OpCooperativeMatrixLengthKHR"}; + return true; + } + case SpvOpTypeRayQueryKHR: + { + v = UnownedStringSlice{"OpTypeRayQueryKHR"}; + return true; + } + case SpvOpRayQueryInitializeKHR: + { + v = UnownedStringSlice{"OpRayQueryInitializeKHR"}; + return true; + } + case SpvOpRayQueryTerminateKHR: + { + v = UnownedStringSlice{"OpRayQueryTerminateKHR"}; + return true; + } + case SpvOpRayQueryGenerateIntersectionKHR: + { + v = UnownedStringSlice{"OpRayQueryGenerateIntersectionKHR"}; + return true; + } + case SpvOpRayQueryConfirmIntersectionKHR: + { + v = UnownedStringSlice{"OpRayQueryConfirmIntersectionKHR"}; + return true; + } + case SpvOpRayQueryProceedKHR: + { + v = UnownedStringSlice{"OpRayQueryProceedKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionTypeKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionTypeKHR"}; + return true; + } + case SpvOpImageSampleWeightedQCOM: + { + v = UnownedStringSlice{"OpImageSampleWeightedQCOM"}; + return true; + } + case SpvOpImageBoxFilterQCOM: + { + v = UnownedStringSlice{"OpImageBoxFilterQCOM"}; + return true; + } + case SpvOpImageBlockMatchSSDQCOM: + { + v = UnownedStringSlice{"OpImageBlockMatchSSDQCOM"}; + return true; + } + case SpvOpImageBlockMatchSADQCOM: + { + v = UnownedStringSlice{"OpImageBlockMatchSADQCOM"}; + return true; + } + case SpvOpGroupIAddNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupIAddNonUniformAMD"}; + return true; + } + case SpvOpGroupFAddNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupFAddNonUniformAMD"}; + return true; + } + case SpvOpGroupFMinNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupFMinNonUniformAMD"}; + return true; + } + case SpvOpGroupUMinNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupUMinNonUniformAMD"}; + return true; + } + case SpvOpGroupSMinNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupSMinNonUniformAMD"}; + return true; + } + case SpvOpGroupFMaxNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupFMaxNonUniformAMD"}; + return true; + } + case SpvOpGroupUMaxNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupUMaxNonUniformAMD"}; + return true; + } + case SpvOpGroupSMaxNonUniformAMD: + { + v = UnownedStringSlice{"OpGroupSMaxNonUniformAMD"}; + return true; + } + case SpvOpFragmentMaskFetchAMD: + { + v = UnownedStringSlice{"OpFragmentMaskFetchAMD"}; + return true; + } + case SpvOpFragmentFetchAMD: + { + v = UnownedStringSlice{"OpFragmentFetchAMD"}; + return true; + } + case SpvOpReadClockKHR: + { + v = UnownedStringSlice{"OpReadClockKHR"}; + return true; + } + case SpvOpHitObjectRecordHitMotionNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitMotionNV"}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexMotionNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitWithIndexMotionNV"}; + return true; + } + case SpvOpHitObjectRecordMissMotionNV: + { + v = UnownedStringSlice{"OpHitObjectRecordMissMotionNV"}; + return true; + } + case SpvOpHitObjectGetWorldToObjectNV: + { + v = UnownedStringSlice{"OpHitObjectGetWorldToObjectNV"}; + return true; + } + case SpvOpHitObjectGetObjectToWorldNV: + { + v = UnownedStringSlice{"OpHitObjectGetObjectToWorldNV"}; + return true; + } + case SpvOpHitObjectGetObjectRayDirectionNV: + { + v = UnownedStringSlice{"OpHitObjectGetObjectRayDirectionNV"}; + return true; + } + case SpvOpHitObjectGetObjectRayOriginNV: + { + v = UnownedStringSlice{"OpHitObjectGetObjectRayOriginNV"}; + return true; + } + case SpvOpHitObjectTraceRayMotionNV: + { + v = UnownedStringSlice{"OpHitObjectTraceRayMotionNV"}; + return true; + } + case SpvOpHitObjectGetShaderRecordBufferHandleNV: + { + v = UnownedStringSlice{"OpHitObjectGetShaderRecordBufferHandleNV"}; + return true; + } + case SpvOpHitObjectGetShaderBindingTableRecordIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetShaderBindingTableRecordIndexNV"}; + return true; + } + case SpvOpHitObjectRecordEmptyNV: + { + v = UnownedStringSlice{"OpHitObjectRecordEmptyNV"}; + return true; + } + case SpvOpHitObjectTraceRayNV: + { + v = UnownedStringSlice{"OpHitObjectTraceRayNV"}; + return true; + } + case SpvOpHitObjectRecordHitNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitNV"}; + return true; + } + case SpvOpHitObjectRecordHitWithIndexNV: + { + v = UnownedStringSlice{"OpHitObjectRecordHitWithIndexNV"}; + return true; + } + case SpvOpHitObjectRecordMissNV: + { + v = UnownedStringSlice{"OpHitObjectRecordMissNV"}; + return true; + } + case SpvOpHitObjectExecuteShaderNV: + { + v = UnownedStringSlice{"OpHitObjectExecuteShaderNV"}; + return true; + } + case SpvOpHitObjectGetCurrentTimeNV: + { + v = UnownedStringSlice{"OpHitObjectGetCurrentTimeNV"}; + return true; + } + case SpvOpHitObjectGetAttributesNV: + { + v = UnownedStringSlice{"OpHitObjectGetAttributesNV"}; + return true; + } + case SpvOpHitObjectGetHitKindNV: + { + v = UnownedStringSlice{"OpHitObjectGetHitKindNV"}; + return true; + } + case SpvOpHitObjectGetPrimitiveIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetPrimitiveIndexNV"}; + return true; + } + case SpvOpHitObjectGetGeometryIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetGeometryIndexNV"}; + return true; + } + case SpvOpHitObjectGetInstanceIdNV: + { + v = UnownedStringSlice{"OpHitObjectGetInstanceIdNV"}; + return true; + } + case SpvOpHitObjectGetInstanceCustomIndexNV: + { + v = UnownedStringSlice{"OpHitObjectGetInstanceCustomIndexNV"}; + return true; + } + case SpvOpHitObjectGetWorldRayDirectionNV: + { + v = UnownedStringSlice{"OpHitObjectGetWorldRayDirectionNV"}; + return true; + } + case SpvOpHitObjectGetWorldRayOriginNV: + { + v = UnownedStringSlice{"OpHitObjectGetWorldRayOriginNV"}; + return true; + } + case SpvOpHitObjectGetRayTMaxNV: + { + v = UnownedStringSlice{"OpHitObjectGetRayTMaxNV"}; + return true; + } + case SpvOpHitObjectGetRayTMinNV: + { + v = UnownedStringSlice{"OpHitObjectGetRayTMinNV"}; + return true; + } + case SpvOpHitObjectIsEmptyNV: + { + v = UnownedStringSlice{"OpHitObjectIsEmptyNV"}; + return true; + } + case SpvOpHitObjectIsHitNV: + { + v = UnownedStringSlice{"OpHitObjectIsHitNV"}; + return true; + } + case SpvOpHitObjectIsMissNV: + { + v = UnownedStringSlice{"OpHitObjectIsMissNV"}; + return true; + } + case SpvOpReorderThreadWithHitObjectNV: + { + v = UnownedStringSlice{"OpReorderThreadWithHitObjectNV"}; + return true; + } + case SpvOpReorderThreadWithHintNV: + { + v = UnownedStringSlice{"OpReorderThreadWithHintNV"}; + return true; + } + case SpvOpTypeHitObjectNV: + { + v = UnownedStringSlice{"OpTypeHitObjectNV"}; + return true; + } + case SpvOpImageSampleFootprintNV: + { + v = UnownedStringSlice{"OpImageSampleFootprintNV"}; + return true; + } + case SpvOpEmitMeshTasksEXT: + { + v = UnownedStringSlice{"OpEmitMeshTasksEXT"}; + return true; + } + case SpvOpSetMeshOutputsEXT: + { + v = UnownedStringSlice{"OpSetMeshOutputsEXT"}; + return true; + } + case SpvOpGroupNonUniformPartitionNV: + { + v = UnownedStringSlice{"OpGroupNonUniformPartitionNV"}; + return true; + } + case SpvOpWritePackedPrimitiveIndices4x8NV: + { + v = UnownedStringSlice{"OpWritePackedPrimitiveIndices4x8NV"}; + return true; + } + case SpvOpReportIntersectionNV: + { + v = UnownedStringSlice{"OpReportIntersectionNV"}; + return true; + } + case SpvOpIgnoreIntersectionNV: + { + v = UnownedStringSlice{"OpIgnoreIntersectionNV"}; + return true; + } + case SpvOpTerminateRayNV: + { + v = UnownedStringSlice{"OpTerminateRayNV"}; + return true; + } + case SpvOpTraceNV: + { + v = UnownedStringSlice{"OpTraceNV"}; + return true; + } + case SpvOpTraceMotionNV: + { + v = UnownedStringSlice{"OpTraceMotionNV"}; + return true; + } + case SpvOpTraceRayMotionNV: + { + v = UnownedStringSlice{"OpTraceRayMotionNV"}; + return true; + } + case SpvOpRayQueryGetIntersectionTriangleVertexPositionsKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionTriangleVertexPositionsKHR"}; + return true; + } + case SpvOpTypeAccelerationStructureNV: + { + v = UnownedStringSlice{"OpTypeAccelerationStructureNV"}; + return true; + } + case SpvOpExecuteCallableNV: + { + v = UnownedStringSlice{"OpExecuteCallableNV"}; + return true; + } + case SpvOpTypeCooperativeMatrixNV: + { + v = UnownedStringSlice{"OpTypeCooperativeMatrixNV"}; + return true; + } + case SpvOpCooperativeMatrixLoadNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixLoadNV"}; + return true; + } + case SpvOpCooperativeMatrixStoreNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixStoreNV"}; + return true; + } + case SpvOpCooperativeMatrixMulAddNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixMulAddNV"}; + return true; + } + case SpvOpCooperativeMatrixLengthNV: + { + v = UnownedStringSlice{"OpCooperativeMatrixLengthNV"}; + return true; + } + case SpvOpBeginInvocationInterlockEXT: + { + v = UnownedStringSlice{"OpBeginInvocationInterlockEXT"}; + return true; + } + case SpvOpEndInvocationInterlockEXT: + { + v = UnownedStringSlice{"OpEndInvocationInterlockEXT"}; + return true; + } + case SpvOpDemoteToHelperInvocation: + { + v = UnownedStringSlice{"OpDemoteToHelperInvocation"}; + return true; + } + case SpvOpIsHelperInvocationEXT: + { + v = UnownedStringSlice{"OpIsHelperInvocationEXT"}; + return true; + } + case SpvOpConvertUToImageNV: + { + v = UnownedStringSlice{"OpConvertUToImageNV"}; + return true; + } + case SpvOpConvertUToSamplerNV: + { + v = UnownedStringSlice{"OpConvertUToSamplerNV"}; + return true; + } + case SpvOpConvertImageToUNV: + { + v = UnownedStringSlice{"OpConvertImageToUNV"}; + return true; + } + case SpvOpConvertSamplerToUNV: + { + v = UnownedStringSlice{"OpConvertSamplerToUNV"}; + return true; + } + case SpvOpConvertUToSampledImageNV: + { + v = UnownedStringSlice{"OpConvertUToSampledImageNV"}; + return true; + } + case SpvOpConvertSampledImageToUNV: + { + v = UnownedStringSlice{"OpConvertSampledImageToUNV"}; + return true; + } + case SpvOpSamplerImageAddressingModeNV: + { + v = UnownedStringSlice{"OpSamplerImageAddressingModeNV"}; + return true; + } + case SpvOpSubgroupShuffleINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleINTEL"}; + return true; + } + case SpvOpSubgroupShuffleDownINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleDownINTEL"}; + return true; + } + case SpvOpSubgroupShuffleUpINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleUpINTEL"}; + return true; + } + case SpvOpSubgroupShuffleXorINTEL: + { + v = UnownedStringSlice{"OpSubgroupShuffleXorINTEL"}; + return true; + } + case SpvOpSubgroupBlockReadINTEL: + { + v = UnownedStringSlice{"OpSubgroupBlockReadINTEL"}; + return true; + } + case SpvOpSubgroupBlockWriteINTEL: + { + v = UnownedStringSlice{"OpSubgroupBlockWriteINTEL"}; + return true; + } + case SpvOpSubgroupImageBlockReadINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageBlockReadINTEL"}; + return true; + } + case SpvOpSubgroupImageBlockWriteINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageBlockWriteINTEL"}; + return true; + } + case SpvOpSubgroupImageMediaBlockReadINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageMediaBlockReadINTEL"}; + return true; + } + case SpvOpSubgroupImageMediaBlockWriteINTEL: + { + v = UnownedStringSlice{"OpSubgroupImageMediaBlockWriteINTEL"}; + return true; + } + case SpvOpUCountLeadingZerosINTEL: + { + v = UnownedStringSlice{"OpUCountLeadingZerosINTEL"}; + return true; + } + case SpvOpUCountTrailingZerosINTEL: + { + v = UnownedStringSlice{"OpUCountTrailingZerosINTEL"}; + return true; + } + case SpvOpAbsISubINTEL: + { + v = UnownedStringSlice{"OpAbsISubINTEL"}; + return true; + } + case SpvOpAbsUSubINTEL: + { + v = UnownedStringSlice{"OpAbsUSubINTEL"}; + return true; + } + case SpvOpIAddSatINTEL: + { + v = UnownedStringSlice{"OpIAddSatINTEL"}; + return true; + } + case SpvOpUAddSatINTEL: + { + v = UnownedStringSlice{"OpUAddSatINTEL"}; + return true; + } + case SpvOpIAverageINTEL: + { + v = UnownedStringSlice{"OpIAverageINTEL"}; + return true; + } + case SpvOpUAverageINTEL: + { + v = UnownedStringSlice{"OpUAverageINTEL"}; + return true; + } + case SpvOpIAverageRoundedINTEL: + { + v = UnownedStringSlice{"OpIAverageRoundedINTEL"}; + return true; + } + case SpvOpUAverageRoundedINTEL: + { + v = UnownedStringSlice{"OpUAverageRoundedINTEL"}; + return true; + } + case SpvOpISubSatINTEL: + { + v = UnownedStringSlice{"OpISubSatINTEL"}; + return true; + } + case SpvOpUSubSatINTEL: + { + v = UnownedStringSlice{"OpUSubSatINTEL"}; + return true; + } + case SpvOpIMul32x16INTEL: + { + v = UnownedStringSlice{"OpIMul32x16INTEL"}; + return true; + } + case SpvOpUMul32x16INTEL: + { + v = UnownedStringSlice{"OpUMul32x16INTEL"}; + return true; + } + case SpvOpConstantFunctionPointerINTEL: + { + v = UnownedStringSlice{"OpConstantFunctionPointerINTEL"}; + return true; + } + case SpvOpFunctionPointerCallINTEL: + { + v = UnownedStringSlice{"OpFunctionPointerCallINTEL"}; + return true; + } + case SpvOpAsmTargetINTEL: + { + v = UnownedStringSlice{"OpAsmTargetINTEL"}; + return true; + } + case SpvOpAsmINTEL: + { + v = UnownedStringSlice{"OpAsmINTEL"}; + return true; + } + case SpvOpAsmCallINTEL: + { + v = UnownedStringSlice{"OpAsmCallINTEL"}; + return true; + } + case SpvOpAtomicFMinEXT: + { + v = UnownedStringSlice{"OpAtomicFMinEXT"}; + return true; + } + case SpvOpAtomicFMaxEXT: + { + v = UnownedStringSlice{"OpAtomicFMaxEXT"}; + return true; + } + case SpvOpAssumeTrueKHR: + { + v = UnownedStringSlice{"OpAssumeTrueKHR"}; + return true; + } + case SpvOpExpectKHR: + { + v = UnownedStringSlice{"OpExpectKHR"}; + return true; + } + case SpvOpDecorateString: + { + v = UnownedStringSlice{"OpDecorateString"}; + return true; + } + case SpvOpMemberDecorateString: + { + v = UnownedStringSlice{"OpMemberDecorateString"}; + return true; + } + case SpvOpVmeImageINTEL: + { + v = UnownedStringSlice{"OpVmeImageINTEL"}; + return true; + } + case SpvOpTypeVmeImageINTEL: + { + v = UnownedStringSlice{"OpTypeVmeImageINTEL"}; + return true; + } + case SpvOpTypeAvcImePayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImePayloadINTEL"}; + return true; + } + case SpvOpTypeAvcRefPayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcRefPayloadINTEL"}; + return true; + } + case SpvOpTypeAvcSicPayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcSicPayloadINTEL"}; + return true; + } + case SpvOpTypeAvcMcePayloadINTEL: + { + v = UnownedStringSlice{"OpTypeAvcMcePayloadINTEL"}; + return true; + } + case SpvOpTypeAvcMceResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcMceResultINTEL"}; + return true; + } + case SpvOpTypeAvcImeResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeResultINTEL"}; + return true; + } + case SpvOpTypeAvcImeResultSingleReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeResultSingleReferenceStreamoutINTEL"}; + return true; + } + case SpvOpTypeAvcImeResultDualReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeResultDualReferenceStreamoutINTEL"}; + return true; + } + case SpvOpTypeAvcImeSingleReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeSingleReferenceStreaminINTEL"}; + return true; + } + case SpvOpTypeAvcImeDualReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpTypeAvcImeDualReferenceStreaminINTEL"}; + return true; + } + case SpvOpTypeAvcRefResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcRefResultINTEL"}; + return true; + } + case SpvOpTypeAvcSicResultINTEL: + { + v = UnownedStringSlice{"OpTypeAvcSicResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetInterShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetInterShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetInterDirectionPenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetInterDirectionPenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetAcOnlyHaarINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetAcOnlyHaarINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToImePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToImeResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToImeResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefPayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToRefPayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToRefResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToRefResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicPayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToSicPayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceConvertToSicResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceConvertToSicResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetMotionVectorsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetMotionVectorsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetBestInterDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetBestInterDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMajorShapeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterMajorShapeINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMinorShapeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterMinorShapeINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterDirectionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterDirectionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterMotionVectorCountINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterMotionVectorCountINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceIdsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterReferenceIdsINTEL"}; + return true; + } + case SpvOpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeRefWindowSizeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeRefWindowSizeINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeAdjustRefOffsetINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeAdjustRefOffsetINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMcePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeConvertToMcePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetMaxMotionVectorCountINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetMaxMotionVectorCountINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeSetWeightedSadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeSetWeightedSadINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeConvertToMceResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeConvertToMceResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetSingleReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetSingleReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetDualReferenceStreaminINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetDualReferenceStreaminINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeStripDualReferenceStreamoutINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeStripDualReferenceStreamoutINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetBorderReachedINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetBorderReachedINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL"}; + return true; + } + case SpvOpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL"}; + return true; + } + case SpvOpSubgroupAvcFmeInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcFmeInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcBmeInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcBmeInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMcePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefConvertToMcePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefSetBidirectionalMixDisableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefSetBidirectionalMixDisableINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefSetBilinearFilterEnableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefSetBilinearFilterEnableINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL"}; + return true; + } + case SpvOpSubgroupAvcRefConvertToMceResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcRefConvertToMceResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicInitializeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicInitializeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConfigureSkcINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConfigureSkcINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConfigureIpeLumaINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConfigureIpeLumaChromaINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConfigureIpeLumaChromaINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetMotionVectorMaskINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetMotionVectorMaskINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMcePayloadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConvertToMcePayloadINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetBilinearFilterEnableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetBilinearFilterEnableINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateIpeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateIpeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithDualReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithDualReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicConvertToMceResultINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicConvertToMceResultINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeLumaShapeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetIpeLumaShapeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedIpeLumaModesINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetPackedIpeLumaModesINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetIpeChromaModeINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetIpeChromaModeINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL"}; + return true; + } + case SpvOpSubgroupAvcSicGetInterRawSadsINTEL: + { + v = UnownedStringSlice{"OpSubgroupAvcSicGetInterRawSadsINTEL"}; + return true; + } + case SpvOpVariableLengthArrayINTEL: + { + v = UnownedStringSlice{"OpVariableLengthArrayINTEL"}; + return true; + } + case SpvOpSaveMemoryINTEL: + { + v = UnownedStringSlice{"OpSaveMemoryINTEL"}; + return true; + } + case SpvOpRestoreMemoryINTEL: + { + v = UnownedStringSlice{"OpRestoreMemoryINTEL"}; + return true; + } + case SpvOpArbitraryFloatSinCosPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinCosPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatCastINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCastINTEL"}; + return true; + } + case SpvOpArbitraryFloatCastFromIntINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCastFromIntINTEL"}; + return true; + } + case SpvOpArbitraryFloatCastToIntINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCastToIntINTEL"}; + return true; + } + case SpvOpArbitraryFloatAddINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatAddINTEL"}; + return true; + } + case SpvOpArbitraryFloatSubINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSubINTEL"}; + return true; + } + case SpvOpArbitraryFloatMulINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatMulINTEL"}; + return true; + } + case SpvOpArbitraryFloatDivINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatDivINTEL"}; + return true; + } + case SpvOpArbitraryFloatGTINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatGTINTEL"}; + return true; + } + case SpvOpArbitraryFloatGEINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatGEINTEL"}; + return true; + } + case SpvOpArbitraryFloatLTINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLTINTEL"}; + return true; + } + case SpvOpArbitraryFloatLEINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLEINTEL"}; + return true; + } + case SpvOpArbitraryFloatEQINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatEQINTEL"}; + return true; + } + case SpvOpArbitraryFloatRecipINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatRecipINTEL"}; + return true; + } + case SpvOpArbitraryFloatRSqrtINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatRSqrtINTEL"}; + return true; + } + case SpvOpArbitraryFloatCbrtINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCbrtINTEL"}; + return true; + } + case SpvOpArbitraryFloatHypotINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatHypotINTEL"}; + return true; + } + case SpvOpArbitraryFloatSqrtINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSqrtINTEL"}; + return true; + } + case SpvOpArbitraryFloatLogINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLogINTEL"}; + return true; + } + case SpvOpArbitraryFloatLog2INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLog2INTEL"}; + return true; + } + case SpvOpArbitraryFloatLog10INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLog10INTEL"}; + return true; + } + case SpvOpArbitraryFloatLog1pINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatLog1pINTEL"}; + return true; + } + case SpvOpArbitraryFloatExpINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExpINTEL"}; + return true; + } + case SpvOpArbitraryFloatExp2INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExp2INTEL"}; + return true; + } + case SpvOpArbitraryFloatExp10INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExp10INTEL"}; + return true; + } + case SpvOpArbitraryFloatExpm1INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatExpm1INTEL"}; + return true; + } + case SpvOpArbitraryFloatSinINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinINTEL"}; + return true; + } + case SpvOpArbitraryFloatCosINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCosINTEL"}; + return true; + } + case SpvOpArbitraryFloatSinCosINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinCosINTEL"}; + return true; + } + case SpvOpArbitraryFloatSinPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatSinPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatCosPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatCosPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatASinINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatASinINTEL"}; + return true; + } + case SpvOpArbitraryFloatASinPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatASinPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatACosINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatACosINTEL"}; + return true; + } + case SpvOpArbitraryFloatACosPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatACosPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatATanINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatATanINTEL"}; + return true; + } + case SpvOpArbitraryFloatATanPiINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatATanPiINTEL"}; + return true; + } + case SpvOpArbitraryFloatATan2INTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatATan2INTEL"}; + return true; + } + case SpvOpArbitraryFloatPowINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatPowINTEL"}; + return true; + } + case SpvOpArbitraryFloatPowRINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatPowRINTEL"}; + return true; + } + case SpvOpArbitraryFloatPowNINTEL: + { + v = UnownedStringSlice{"OpArbitraryFloatPowNINTEL"}; + return true; + } + case SpvOpLoopControlINTEL: + { + v = UnownedStringSlice{"OpLoopControlINTEL"}; + return true; + } + case SpvOpAliasDomainDeclINTEL: + { + v = UnownedStringSlice{"OpAliasDomainDeclINTEL"}; + return true; + } + case SpvOpAliasScopeDeclINTEL: + { + v = UnownedStringSlice{"OpAliasScopeDeclINTEL"}; + return true; + } + case SpvOpAliasScopeListDeclINTEL: + { + v = UnownedStringSlice{"OpAliasScopeListDeclINTEL"}; + return true; + } + case SpvOpFixedSqrtINTEL: + { + v = UnownedStringSlice{"OpFixedSqrtINTEL"}; + return true; + } + case SpvOpFixedRecipINTEL: + { + v = UnownedStringSlice{"OpFixedRecipINTEL"}; + return true; + } + case SpvOpFixedRsqrtINTEL: + { + v = UnownedStringSlice{"OpFixedRsqrtINTEL"}; + return true; + } + case SpvOpFixedSinINTEL: + { + v = UnownedStringSlice{"OpFixedSinINTEL"}; + return true; + } + case SpvOpFixedCosINTEL: + { + v = UnownedStringSlice{"OpFixedCosINTEL"}; + return true; + } + case SpvOpFixedSinCosINTEL: + { + v = UnownedStringSlice{"OpFixedSinCosINTEL"}; + return true; + } + case SpvOpFixedSinPiINTEL: + { + v = UnownedStringSlice{"OpFixedSinPiINTEL"}; + return true; + } + case SpvOpFixedCosPiINTEL: + { + v = UnownedStringSlice{"OpFixedCosPiINTEL"}; + return true; + } + case SpvOpFixedSinCosPiINTEL: + { + v = UnownedStringSlice{"OpFixedSinCosPiINTEL"}; + return true; + } + case SpvOpFixedLogINTEL: + { + v = UnownedStringSlice{"OpFixedLogINTEL"}; + return true; + } + case SpvOpFixedExpINTEL: + { + v = UnownedStringSlice{"OpFixedExpINTEL"}; + return true; + } + case SpvOpPtrCastToCrossWorkgroupINTEL: + { + v = UnownedStringSlice{"OpPtrCastToCrossWorkgroupINTEL"}; + return true; + } + case SpvOpCrossWorkgroupCastToPtrINTEL: + { + v = UnownedStringSlice{"OpCrossWorkgroupCastToPtrINTEL"}; + return true; + } + case SpvOpReadPipeBlockingINTEL: + { + v = UnownedStringSlice{"OpReadPipeBlockingINTEL"}; + return true; + } + case SpvOpWritePipeBlockingINTEL: + { + v = UnownedStringSlice{"OpWritePipeBlockingINTEL"}; + return true; + } + case SpvOpFPGARegINTEL: + { + v = UnownedStringSlice{"OpFPGARegINTEL"}; + return true; + } + case SpvOpRayQueryGetRayTMinKHR: + { + v = UnownedStringSlice{"OpRayQueryGetRayTMinKHR"}; + return true; + } + case SpvOpRayQueryGetRayFlagsKHR: + { + v = UnownedStringSlice{"OpRayQueryGetRayFlagsKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionTKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionTKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceCustomIndexKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionInstanceCustomIndexKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceIdKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionInstanceIdKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionGeometryIndexKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionGeometryIndexKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionPrimitiveIndexKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionPrimitiveIndexKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionBarycentricsKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionBarycentricsKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionFrontFaceKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionFrontFaceKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionCandidateAABBOpaqueKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionCandidateAABBOpaqueKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayDirectionKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionObjectRayDirectionKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectRayOriginKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionObjectRayOriginKHR"}; + return true; + } + case SpvOpRayQueryGetWorldRayDirectionKHR: + { + v = UnownedStringSlice{"OpRayQueryGetWorldRayDirectionKHR"}; + return true; + } + case SpvOpRayQueryGetWorldRayOriginKHR: + { + v = UnownedStringSlice{"OpRayQueryGetWorldRayOriginKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionObjectToWorldKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionObjectToWorldKHR"}; + return true; + } + case SpvOpRayQueryGetIntersectionWorldToObjectKHR: + { + v = UnownedStringSlice{"OpRayQueryGetIntersectionWorldToObjectKHR"}; + return true; + } + case SpvOpAtomicFAddEXT: + { + v = UnownedStringSlice{"OpAtomicFAddEXT"}; + return true; + } + case SpvOpTypeBufferSurfaceINTEL: + { + v = UnownedStringSlice{"OpTypeBufferSurfaceINTEL"}; + return true; + } + case SpvOpTypeStructContinuedINTEL: + { + v = UnownedStringSlice{"OpTypeStructContinuedINTEL"}; + return true; + } + case SpvOpConstantCompositeContinuedINTEL: + { + v = UnownedStringSlice{"OpConstantCompositeContinuedINTEL"}; + return true; + } + case SpvOpSpecConstantCompositeContinuedINTEL: + { + v = UnownedStringSlice{"OpSpecConstantCompositeContinuedINTEL"}; + return true; + } + case SpvOpConvertFToBF16INTEL: + { + v = UnownedStringSlice{"OpConvertFToBF16INTEL"}; + return true; + } + case SpvOpConvertBF16ToFINTEL: + { + v = UnownedStringSlice{"OpConvertBF16ToFINTEL"}; + return true; + } + case SpvOpControlBarrierArriveINTEL: + { + v = UnownedStringSlice{"OpControlBarrierArriveINTEL"}; + return true; + } + case SpvOpControlBarrierWaitINTEL: + { + v = UnownedStringSlice{"OpControlBarrierWaitINTEL"}; + return true; + } + case SpvOpGroupIMulKHR: + { + v = UnownedStringSlice{"OpGroupIMulKHR"}; + return true; + } + case SpvOpGroupFMulKHR: + { + v = UnownedStringSlice{"OpGroupFMulKHR"}; + return true; + } + case SpvOpGroupBitwiseAndKHR: + { + v = UnownedStringSlice{"OpGroupBitwiseAndKHR"}; + return true; + } + case SpvOpGroupBitwiseOrKHR: + { + v = UnownedStringSlice{"OpGroupBitwiseOrKHR"}; + return true; + } + case SpvOpGroupBitwiseXorKHR: + { + v = UnownedStringSlice{"OpGroupBitwiseXorKHR"}; + return true; + } + case SpvOpGroupLogicalAndKHR: + { + v = UnownedStringSlice{"OpGroupLogicalAndKHR"}; + return true; + } + case SpvOpGroupLogicalOrKHR: + { + v = UnownedStringSlice{"OpGroupLogicalOrKHR"}; + return true; + } + case SpvOpGroupLogicalXorKHR: + { + v = UnownedStringSlice{"OpGroupLogicalXorKHR"}; + return true; + } + default: return false; + } +} + +static bool lookupOperandKind(const UnownedStringSlice& str, OperandKind& value) +{ + static const unsigned tableSalt[56] = { + 3, 1, 3, 1, 0, 3, 0, 0, 3, 0, 1, 1, 1, 3, 6, 2, + 1, 2, 0, 0, 2, 1, 0, 1, 6, 1, 0, 0, 0, 2, 5, 6, + 2, 0, 1, 0, 9, 2, 1, 5, 11, 7, 0, 0, 2, 0, 3, 0, + 0, 2, 0, 20, 4, 7, 0, 9 + }; + + using KV = std::pair<const char*, OperandKind>; + + static const KV words[56] = + { + {"QuantizationModes", OperandKind{24}}, + {"PairIdRefIdRef", OperandKind{55}}, + {"CooperativeMatrixOperands", OperandKind{40}}, + {"LiteralSpecConstantOpInteger", OperandKind{52}}, + {"SamplerFilterMode", OperandKind{18}}, + {"Decoration", OperandKind{30}}, + {"ImageChannelDataType", OperandKind{21}}, + {"LiteralInteger", OperandKind{48}}, + {"IdMemorySemantics", OperandKind{45}}, + {"AccessQualifier", OperandKind{28}}, + {"LinkageType", OperandKind{27}}, + {"BuiltIn", OperandKind{31}}, + {"SamplerAddressingMode", OperandKind{17}}, + {"IdRef", OperandKind{47}}, + {"Scope", OperandKind{32}}, + {"ImageChannelOrder", OperandKind{20}}, + {"ExecutionModel", OperandKind{11}}, + {"FragmentShadingRate", OperandKind{9}}, + {"LiteralExtInstInteger", OperandKind{51}}, + {"LiteralString", OperandKind{49}}, + {"SourceLanguage", OperandKind{10}}, + {"LiteralContextDependentNumber", OperandKind{50}}, + {"FPRoundingMode", OperandKind{22}}, + {"FPOperationMode", OperandKind{25}}, + {"RayQueryCommittedIntersectionType", OperandKind{37}}, + {"CooperativeMatrixUse", OperandKind{42}}, + {"MemoryAccess", OperandKind{6}}, + {"PackedVectorFormat", OperandKind{39}}, + {"FunctionControl", OperandKind{4}}, + {"FunctionParameterAttribute", OperandKind{29}}, + {"MemoryModel", OperandKind{13}}, + {"StorageClass", OperandKind{15}}, + {"ImageFormat", OperandKind{19}}, + {"MemorySemantics", OperandKind{5}}, + {"KernelEnqueueFlags", OperandKind{34}}, + {"LoopControl", OperandKind{3}}, + {"PairLiteralIntegerIdRef", OperandKind{53}}, + {"IdResult", OperandKind{44}}, + {"ImageOperands", OperandKind{0}}, + {"Capability", OperandKind{35}}, + {"FPDenormMode", OperandKind{23}}, + {"Dim", OperandKind{16}}, + {"RayQueryIntersection", OperandKind{36}}, + {"IdScope", OperandKind{46}}, + {"ExecutionMode", OperandKind{14}}, + {"AddressingModel", OperandKind{12}}, + {"CooperativeMatrixLayout", OperandKind{41}}, + {"RayFlags", OperandKind{8}}, + {"SelectionControl", OperandKind{2}}, + {"OverflowModes", OperandKind{26}}, + {"FPFastMathMode", OperandKind{1}}, + {"RayQueryCandidateIntersectionType", OperandKind{38}}, + {"PairIdRefLiteralInteger", OperandKind{54}}, + {"IdResultType", OperandKind{43}}, + {"GroupOperation", OperandKind{33}}, + {"KernelProfilingInfo", OperandKind{7}}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 56; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +bool lookupEnumWithHexPrefix(const UnownedStringSlice& str, SpvWord& value) +{ + static const unsigned tableSalt[944] = { + 1, 0, 0, 0, 2, 3, 2, 1, 3, 2, 0, 8, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 4, 0, 2, 0, 0, 2, 3, 1, + 2, 2, 5, 0, 3, 1, 4, 1, 0, 4, 3, 3, 0, 1, 0, 0, + 1, 1, 1, 0, 1, 2, 3, 0, 0, 0, 1, 0, 1, 0, 0, 1, + 0, 0, 0, 1, 0, 4, 0, 2, 0, 0, 5, 0, 0, 0, 0, 2, + 0, 3, 0, 0, 0, 0, 0, 1, 0, 8, 1, 1, 11, 3, 2, 0, + 1, 1, 21, 0, 0, 2, 4, 0, 2, 3, 6, 3, 0, 0, 0, 6, + 0, 1, 17, 0, 2, 0, 10, 1, 0, 0, 1, 1, 0, 8, 0, 0, + 2, 1, 2, 1, 0, 0, 1, 0, 0, 0, 2, 2, 0, 1, 0, 3, + 3, 0, 2, 0, 4, 0, 0, 1, 1, 0, 0, 2, 1, 5, 0, 2, + 0, 1, 1, 1, 0, 0, 0, 0, 3, 0, 0, 0, 6, 0, 4, 6, + 1, 0, 1, 2, 10, 0, 1, 0, 0, 3, 2, 5, 1, 0, 2, 0, + 2, 3, 0, 7, 1, 4, 2, 0, 1, 0, 1, 0, 0, 0, 0, 9, + 7, 0, 1, 9, 1, 5, 0, 0, 0, 1, 0, 2, 0, 11, 2, 0, + 3, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 9, 8, 4, 1, + 0, 5, 0, 0, 0, 7, 9, 6, 0, 3, 0, 1, 3, 0, 2, 5, + 0, 1, 0, 2, 0, 1, 0, 0, 0, 1, 3, 2, 0, 0, 5, 0, + 5, 0, 1, 18, 1, 0, 0, 0, 4, 0, 0, 1, 0, 0, 1, 2, + 2, 3, 2, 9, 3, 0, 3, 3, 1, 0, 1, 2, 1, 2, 1, 0, + 0, 2, 0, 3, 2, 2, 0, 0, 3, 2, 0, 0, 2, 0, 3, 0, + 0, 0, 0, 5, 1, 0, 3, 2, 0, 0, 11, 3, 2, 0, 0, 7, + 0, 0, 4, 6, 5, 0, 0, 2, 3, 2, 0, 0, 3, 14, 4, 6, + 1, 6, 1, 0, 0, 2, 0, 1, 1, 11, 8, 0, 3, 1, 3, 4, + 0, 0, 0, 0, 1, 1, 0, 1, 2, 7, 1, 0, 0, 0, 13, 0, + 4, 0, 0, 0, 2, 1, 1, 7, 5, 4, 3, 1, 0, 3, 2, 2, + 0, 0, 0, 6, 18, 0, 0, 0, 3, 3, 4, 5, 4, 0, 1, 5, + 3, 0, 4, 5, 6, 9, 1, 3, 0, 0, 0, 1, 0, 1, 2, 7, + 0, 3, 1, 0, 9, 2, 0, 0, 0, 6, 4, 1, 8, 1, 0, 1, + 4, 2, 1, 0, 1, 4, 0, 5, 0, 4, 0, 3, 0, 1, 5, 6, + 0, 1, 1, 4, 0, 2, 6, 5, 1, 5, 1, 2, 2, 1, 0, 2, + 10, 0, 0, 4, 0, 1, 0, 1, 1, 8, 2, 2, 4, 1, 0, 0, + 1, 3, 14, 8, 2, 15, 3, 1, 5, 11, 5, 0, 0, 1, 3, 0, + 2, 0, 3, 0, 1, 3, 2, 5, 1, 4, 1, 6, 0, 0, 2, 1, + 0, 2, 0, 0, 0, 1, 0, 2, 0, 3, 0, 0, 6, 2, 18, 3, + 1, 7, 0, 4, 0, 4, 0, 0, 2, 3, 2, 2, 0, 8, 0, 0, + 10, 0, 0, 9, 1, 4, 3, 6, 0, 1, 6, 3, 14, 0, 0, 0, + 0, 0, 0, 11, 9, 5, 1, 0, 8, 0, 0, 0, 0, 0, 0, 0, + 2, 1, 0, 0, 3, 0, 0, 0, 1, 1, 1, 0, 5, 9, 0, 0, + 5, 11, 3, 4, 8, 0, 3, 5, 3, 0, 3, 1, 19, 0, 0, 1, + 27, 7, 6, 2, 6, 4, 29, 1, 14, 5, 6, 0, 4, 1, 0, 0, + 1, 4, 6, 0, 1, 0, 19, 18, 9, 1, 0, 12, 1, 1, 0, 0, + 2, 0, 0, 12, 0, 0, 25, 0, 12, 11, 4, 2, 0, 2, 0, 34, + 0, 0, 5, 2, 0, 4, 0, 0, 36, 4, 0, 6, 6, 3, 12, 0, + 1, 1, 3, 0, 0, 0, 8, 4, 0, 14, 0, 0, 21, 7, 2, 0, + 46, 6, 0, 4, 1, 0, 1, 3, 41, 23, 0, 2, 1, 0, 0, 14, + 0, 9, 1, 2, 11, 0, 0, 66, 15, 26, 1, 26, 0, 0, 0, 0, + 1, 0, 2, 1, 2, 14, 0, 0, 12, 1, 17, 1, 2, 4, 5, 3, + 1, 3, 7, 4, 0, 5, 15, 29, 20, 0, 5, 0, 2, 12, 0, 3, + 0, 0, 31, 0, 2, 4, 6, 3, 0, 1, 6, 21, 0, 8, 0, 0, + 0, 4, 0, 1, 3, 1, 5, 6, 0, 1, 1, 0, 9, 9, 5, 14, + 13, 57, 0, 0, 68, 0, 3, 29, 27, 0, 0, 29, 0, 1, 10, 0, + 0, 3, 16, 1, 0, 0, 9, 17, 0, 0, 0, 5, 12, 43, 38, 1, + 0, 1, 8, 47, 5, 0, 1, 0, 0, 1, 0, 0, 0, 0, 5, 0, + 14, 6, 21, 9, 10, 0, 0, 16, 9, 2, 29, 80, 0, 30, 29, 76, + 3, 2, 76, 0, 16, 6, 0, 28, 9, 44, 43, 0, 132, 1, 0, 1, + 1, 1, 2, 0, 0, 0, 6, 120, 17, 169, 2, 3, 56, 0, 0, 0, + 0, 0, 7, 49, 11, 0, 14, 30, 21, 0, 0, 8, 4, 15, 4, 0, + 37, 7, 1, 12, 68, 3, 20, 0, 408, 339, 4, 67, 461, 10, 27, 0, + 0, 0, 0, 0, 0, 0, 1, 0, 415, 2, 1, 0, 1, 0, 3, 172 + }; + + using KV = std::pair<const char*, SpvWord>; + + static const KV words[944] = + { + {"bpRayTmaxKHR", SpvWord{5326}}, + {"bpBaseVertex", SpvWord{4424}}, + {"bpObjectToWorldNV", SpvWord{5330}}, + {"bpTessLevelOuter", SpvWord{11}}, + {"boBufferBlock", SpvWord{3}}, + {"bdR11fG11fB10f", SpvWord{8}}, + {"cdRuntimeDescriptorArray", SpvWord{5302}}, + {"boXfbStride", SpvWord{37}}, + {"bdR16ui", SpvWord{38}}, + {"bpLocalInvocationIndex", SpvWord{29}}, + {"bnSret", SpvWord{3}}, + {"cdFunctionFloatControlINTEL", SpvWord{5821}}, + {"boFuseLoopsInFunctionINTEL", SpvWord{5907}}, + {"anOpenCL", SpvWord{2}}, + {"aiSkipClosestHitShaderKHR", SpvWord{8}}, + {"cdInputAttachment", SpvWord{40}}, + {"bpObjectRayOriginNV", SpvWord{5323}}, + {"aoOriginUpperLeft", SpvWord{7}}, + {"cdFloat64", SpvWord{10}}, + {"bdR32f", SpvWord{3}}, + {"akCPP_for_OpenCL", SpvWord{6}}, + {"anSimple", SpvWord{0}}, + {"boBankBitsINTEL", SpvWord{5835}}, + {"bpNumWorkgroups", SpvWord{24}}, + {"bpPatchVertices", SpvWord{14}}, + {"boInputAttachmentIndex", SpvWord{43}}, + {"aoNumSIMDWorkitemsINTEL", SpvWord{5896}}, + {"boVectorComputeCallableFunctionINTEL", SpvWord{6087}}, + {"boBindlessImageNV", SpvWord{5399}}, + {"boUniform", SpvWord{26}}, + {"cdStorageImageExtendedFormats", SpvWord{49}}, + {"cdTextureBlockMatchQCOM", SpvWord{4486}}, + {"aoMaxWorkgroupSizeINTEL", SpvWord{5893}}, + {"baCube", SpvWord{3}}, + {"aoSubgroupUniformControlFlowKHR", SpvWord{4421}}, + {"apCallableDataKHR", SpvWord{5328}}, + {"agNonPrivatePointer", SpvWord{32}}, + {"aeNone", SpvWord{0}}, + {"boMathOpDSPModeINTEL", SpvWord{5909}}, + {"cdSampledImageArrayNonUniformIndexing", SpvWord{5307}}, + {"beLuminance", SpvWord{9}}, + {"aoPostDepthCoverage", SpvWord{4446}}, + {"bdR16", SpvWord{14}}, + {"bnByVal", SpvWord{2}}, + {"afImageMemory", SpvWord{2048}}, + {"bpBaryCoordNoPerspAMD", SpvWord{4992}}, + {"cdDotProductInput4x8Bit", SpvWord{6017}}, + {"bpPrimitiveShadingRateKHR", SpvWord{4432}}, + {"abNotInf", SpvWord{2}}, + {"bfUnormInt16", SpvWord{3}}, + {"boMaxByteOffsetId", SpvWord{47}}, + {"aoVertexOrderCw", SpvWord{4}}, + {"bkWRAP", SpvWord{0}}, + {"bnNoReadWrite", SpvWord{7}}, + {"cdImageMSArray", SpvWord{48}}, + {"bkSAT", SpvWord{1}}, + {"bpCullMaskKHR", SpvWord{6021}}, + {"boStableKernelArgumentINTEL", SpvWord{6183}}, + {"bpBaryCoordKHR", SpvWord{5286}}, + {"cdStorageUniformBufferBlock16", SpvWord{4433}}, + {"bfUnormShort565", SpvWord{4}}, + {"acFlatten", SpvWord{1}}, + {"bfUnormInt101010_2", SpvWord{16}}, + {"boPerVertexNV", SpvWord{5285}}, + {"cdTileImageStencilReadAccessEXT", SpvWord{4168}}, + {"akUnknown", SpvWord{0}}, + {"bpBaryCoordSmoothCentroidAMD", SpvWord{4996}}, + {"adMaxConcurrencyINTEL", SpvWord{131072}}, + {"cdSubgroupAvcMotionEstimationChromaINTEL", SpvWord{5698}}, + {"cdInputAttachmentArrayDynamicIndexingEXT", SpvWord{5303}}, + {"boLocation", SpvWord{30}}, + {"alMissKHR", SpvWord{5317}}, + {"cbPartitionedInclusiveScanNV", SpvWord{7}}, + {"boInvariant", SpvWord{18}}, + {"alTaskEXT", SpvWord{5364}}, + {"cdLoopFuseINTEL", SpvWord{5906}}, + {"aiCullFrontFacingTrianglesKHR", SpvWord{32}}, + {"bpSampleMask", SpvWord{20}}, + {"cdDotProduct", SpvWord{6019}}, + {"cdFragmentFullyCoveredEXT", SpvWord{5265}}, + {"cdStencilExportEXT", SpvWord{5013}}, + {"boNonUniform", SpvWord{5300}}, + {"cdSampledImageArrayNonUniformIndexingEXT", SpvWord{5307}}, + {"boCoherent", SpvWord{23}}, + {"bpLayerPerViewNV", SpvWord{5279}}, + {"bdRg8Snorm", SpvWord{18}}, + {"bpSubgroupLocalInvocationId", SpvWord{41}}, + {"cbReduce", SpvWord{0}}, + {"boBoundSamplerNV", SpvWord{5400}}, + {"akGLSL", SpvWord{2}}, + {"boCentroid", SpvWord{16}}, + {"apShaderRecordBufferKHR", SpvWord{5343}}, + {"boCounterBuffer", SpvWord{5634}}, + {"boVolatile", SpvWord{21}}, + {"bpWorkgroupId", SpvWord{26}}, + {"boVectorComputeFunctionINTEL", SpvWord{5626}}, + {"ciMatrixASignedComponentsKHR", SpvWord{1}}, + {"boFuncParamIOKindINTEL", SpvWord{5625}}, + {"boFlat", SpvWord{14}}, + {"cdDeviceGroup", SpvWord{4437}}, + {"boPerPrimitiveNV", SpvWord{5271}}, + {"aaSample", SpvWord{64}}, + {"aoRoundingModeRTE", SpvWord{4462}}, + {"bdR16Snorm", SpvWord{19}}, + {"caShaderCallKHR", SpvWord{6}}, + {"blExport", SpvWord{0}}, + {"boIndex", SpvWord{32}}, + {"cdComputeDerivativeGroupQuadsNV", SpvWord{5288}}, + {"bpObjectRayDirectionNV", SpvWord{5324}}, + {"cdInt64", SpvWord{11}}, + {"chPackedVectorFormat4x8BitKHR", SpvWord{0}}, + {"bpFragInvocationCountEXT", SpvWord{5293}}, + {"alIntersectionNV", SpvWord{5314}}, + {"ba1D", SpvWord{0}}, + {"cgRayQueryCandidateIntersectionAABBKHR", SpvWord{1}}, + {"aoInputLines", SpvWord{20}}, + {"aeInline", SpvWord{1}}, + {"cdIOPipesINTEL", SpvWord{5943}}, + {"cdFPGALoopControlsINTEL", SpvWord{5888}}, + {"cdFPGAKernelAttributesv2INTEL", SpvWord{6161}}, + {"cdImageCubeArray", SpvWord{34}}, + {"bpInstanceId", SpvWord{6}}, + {"cdFPGARegINTEL", SpvWord{5948}}, + {"cbClusteredReduce", SpvWord{3}}, + {"aaConstOffsets", SpvWord{32}}, + {"bpHelperInvocation", SpvWord{23}}, + {"aoStencilRefLessBackAMD", SpvWord{5084}}, + {"aeDontInline", SpvWord{2}}, + {"cdUnstructuredLoopControlsINTEL", SpvWord{5886}}, + {"besRGBx", SpvWord{16}}, + {"cdAtomicFloat16MinMaxEXT", SpvWord{5616}}, + {"cdDotProductKHR", SpvWord{6019}}, + {"bpSecondaryPositionNV", SpvWord{5257}}, + {"cdVulkanMemoryModel", SpvWord{5345}}, + {"cdShaderNonUniformEXT", SpvWord{5301}}, + {"alIntersectionKHR", SpvWord{5314}}, + {"boGLSLShared", SpvWord{8}}, + {"bpBaryCoordNoPerspCentroidAMD", SpvWord{4993}}, + {"apPushConstant", SpvWord{9}}, + {"biRND_CONV", SpvWord{6}}, + {"bpFragmentSizeNV", SpvWord{5292}}, + {"aoFinalizer", SpvWord{34}}, + {"bdR8i", SpvWord{29}}, + {"aoQuads", SpvWord{24}}, + {"boHlslCounterBufferGOOGLE", SpvWord{5634}}, + {"boSample", SpvWord{17}}, + {"bdR8", SpvWord{15}}, + {"boPerPrimitiveEXT", SpvWord{5271}}, + {"biRND_ZERO", SpvWord{3}}, + {"bdRgba32ui", SpvWord{30}}, + {"aoDepthReplacing", SpvWord{12}}, + {"cdGroupNonUniformShuffleRelative", SpvWord{66}}, + {"bpSubgroupLtMask", SpvWord{4420}}, + {"aoSchedulerTargetFmaxMhzINTEL", SpvWord{5903}}, + {"cdSubgroupAvcMotionEstimationIntraINTEL", SpvWord{5697}}, + {"cdShaderClockKHR", SpvWord{5055}}, + {"cdUniformBufferArrayNonUniformIndexing", SpvWord{5306}}, + {"boOverrideCoverageNV", SpvWord{5248}}, + {"aoDenormFlushToZero", SpvWord{4460}}, + {"boMMHostInterfaceDataWidthINTEL", SpvWord{6178}}, + {"bfSignedInt16", SpvWord{8}}, + {"bpSubgroupEqMaskKHR", SpvWord{4416}}, + {"aoSubgroupSize", SpvWord{35}}, + {"cdMinLod", SpvWord{42}}, + {"agNoAliasINTELMask", SpvWord{131072}}, + {"aaVolatileTexelKHR", SpvWord{2048}}, + {"bpSMCountNV", SpvWord{5375}}, + {"bpCullDistance", SpvWord{4}}, + {"boAlignment", SpvWord{44}}, + {"aoOutputPoints", SpvWord{27}}, + {"bpWorkgroupSize", SpvWord{25}}, + {"adLoopCoalesceINTEL", SpvWord{1048576}}, + {"cdVariableLengthArrayINTEL", SpvWord{5817}}, + {"bpWarpIDARM", SpvWord{4163}}, + {"apPhysicalStorageBuffer", SpvWord{5349}}, + {"bdRg16Snorm", SpvWord{17}}, + {"boXfbBuffer", SpvWord{36}}, + {"boComponent", SpvWord{31}}, + {"afOutputMemory", SpvWord{4096}}, + {"cdSubgroupAvcMotionEstimationINTEL", SpvWord{5696}}, + {"cdRayTracingNV", SpvWord{5340}}, + {"bpWorldToObjectNV", SpvWord{5331}}, + {"ciMatrixBSignedComponentsKHR", SpvWord{2}}, + {"cdVariablePointersStorageBuffer", SpvWord{4441}}, + {"aoNonCoherentStencilAttachmentReadEXT", SpvWord{4171}}, + {"boBufferLocationINTEL", SpvWord{5921}}, + {"boBindlessSamplerNV", SpvWord{5398}}, + {"cdRayTracingOpacityMicromapEXT", SpvWord{5381}}, + {"cdStorageTexelBufferArrayDynamicIndexingEXT", SpvWord{5305}}, + {"cdStorageImageArrayDynamicIndexing", SpvWord{31}}, + {"cdFloat16", SpvWord{9}}, + {"apStorageBuffer", SpvWord{12}}, + {"bpSubgroupLtMaskKHR", SpvWord{4420}}, + {"cdSparseResidency", SpvWord{41}}, + {"bpWarpIDNV", SpvWord{5376}}, + {"boRestrict", SpvWord{19}}, + {"aoOutputPrimitivesNV", SpvWord{5270}}, + {"boMatrixStride", SpvWord{7}}, + {"cdUSMStorageClassesINTEL", SpvWord{5935}}, + {"cdStorageBufferArrayNonUniformIndexing", SpvWord{5308}}, + {"cdGroupNonUniformRotateKHR", SpvWord{6026}}, + {"aoIsolines", SpvWord{25}}, + {"biTRN", SpvWord{0}}, + {"boFunctionFloatingPointModeINTEL", SpvWord{6080}}, + {"bpPrimitiveId", SpvWord{7}}, + {"boAliased", SpvWord{20}}, + {"akWGSL", SpvWord{10}}, + {"aoShadingRateInterlockOrderedEXT", SpvWord{5370}}, + {"cdMeshShadingEXT", SpvWord{5283}}, + {"ajHorizontal2Pixels", SpvWord{4}}, + {"boUserTypeGOOGLE", SpvWord{5636}}, + {"aoSampleInterlockOrderedEXT", SpvWord{5368}}, + {"cdSubgroupBufferBlockIOINTEL", SpvWord{5569}}, + {"bpObjectRayOriginKHR", SpvWord{5323}}, + {"ajHorizontal4Pixels", SpvWord{8}}, + {"cdVulkanMemoryModelDeviceScope", SpvWord{5346}}, + {"bdRg32f", SpvWord{6}}, + {"cdRayQueryKHR", SpvWord{4472}}, + {"boRelaxedPrecision", SpvWord{0}}, + {"bdRg16", SpvWord{12}}, + {"boHitObjectShaderRecordBufferNV", SpvWord{5386}}, + {"bdRg16ui", SpvWord{36}}, + {"cdSignedZeroInfNanPreserve", SpvWord{4466}}, + {"cdSubgroupBallotKHR", SpvWord{4423}}, + {"agNontemporal", SpvWord{4}}, + {"bpPosition", SpvWord{0}}, + {"blImport", SpvWord{1}}, + {"afMakeAvailable", SpvWord{8192}}, + {"adInitiationIntervalINTEL", SpvWord{65536}}, + {"boAlignmentId", SpvWord{46}}, + {"aoSpacingFractionalOdd", SpvWord{3}}, + {"adLoopCountINTEL", SpvWord{16777216}}, + {"bcLinear", SpvWord{1}}, + {"ckMatrixAKHR", SpvWord{0}}, + {"boDoublepumpINTEL", SpvWord{5831}}, + {"cdFloatingPointModeINTEL", SpvWord{5583}}, + {"bpPositionPerViewNV", SpvWord{5261}}, + {"apImage", SpvWord{11}}, + {"bpInvocationId", SpvWord{8}}, + {"caDevice", SpvWord{1}}, + {"cdVectorAnyINTEL", SpvWord{5619}}, + {"boViewportRelativeNV", SpvWord{5252}}, + {"cdFragmentBarycentricKHR", SpvWord{5284}}, + {"aaMakeTexelAvailableKHR", SpvWord{256}}, + {"ccNoWait", SpvWord{0}}, + {"bpRayTminNV", SpvWord{5325}}, + {"abNotNaN", SpvWord{1}}, + {"bdRgba16Snorm", SpvWord{16}}, + {"aoOutputVertices", SpvWord{26}}, + {"aoStencilRefGreaterFrontAMD", SpvWord{5080}}, + {"boRestrictPointer", SpvWord{5355}}, + {"bgRTN", SpvWord{3}}, + {"cdSplitBarrierINTEL", SpvWord{6141}}, + {"boNonWritable", SpvWord{24}}, + {"bpPointSize", SpvWord{1}}, + {"bfUnormInt8", SpvWord{2}}, + {"aiOpaqueKHR", SpvWord{1}}, + {"boSecondaryViewportRelativeNV", SpvWord{5256}}, + {"cdFunctionPointersINTEL", SpvWord{5603}}, + {"cdDemoteToHelperInvocationEXT", SpvWord{5379}}, + {"cdStorageBufferArrayDynamicIndexing", SpvWord{30}}, + {"boFPRoundingMode", SpvWord{39}}, + {"bpFragSizeEXT", SpvWord{5292}}, + {"cdShader", SpvWord{1}}, + {"ba2D", SpvWord{1}}, + {"boAliasedPointer", SpvWord{5356}}, + {"bnNoAlias", SpvWord{4}}, + {"aaSignExtend", SpvWord{4096}}, + {"bdRgba32f", SpvWord{1}}, + {"cdInt64ImageEXT", SpvWord{5016}}, + {"aoSubgroupsPerWorkgroup", SpvWord{36}}, + {"boRestrictPointerEXT", SpvWord{5355}}, + {"cdVulkanMemoryModelDeviceScopeKHR", SpvWord{5346}}, + {"bdRg32i", SpvWord{25}}, + {"bpVertexIndex", SpvWord{42}}, + {"alTessellationControl", SpvWord{1}}, + {"aoOutputTrianglesNV", SpvWord{5298}}, + {"aoOutputLineStrip", SpvWord{28}}, + {"boFunctionRoundingModeINTEL", SpvWord{5822}}, + {"cdGroupNonUniformShuffle", SpvWord{65}}, + {"bpSubgroupGeMask", SpvWord{4417}}, + {"cdArbitraryPrecisionFloatingPointINTEL", SpvWord{5845}}, + {"afSubgroupMemory", SpvWord{128}}, + {"bdR64ui", SpvWord{40}}, + {"boMaxPrivateCopiesINTEL", SpvWord{5829}}, + {"cdAtomicStorageOps", SpvWord{4445}}, + {"cdStorageBuffer8BitAccess", SpvWord{4448}}, + {"boBlock", SpvWord{2}}, + {"cdSampledCubeArray", SpvWord{45}}, + {"cdMemoryAccessAliasingINTEL", SpvWord{5910}}, + {"adDependencyArrayINTEL", SpvWord{262144}}, + {"cdRoundingModeRTZ", SpvWord{4468}}, + {"afVolatile", SpvWord{32768}}, + {"abFast", SpvWord{16}}, + {"aoContractionOff", SpvWord{31}}, + {"bpNumEnqueuedSubgroups", SpvWord{39}}, + {"aoVecTypeHint", SpvWord{30}}, + {"bdRgba32i", SpvWord{21}}, + {"besRGBA", SpvWord{17}}, + {"ba3D", SpvWord{2}}, + {"apUniformConstant", SpvWord{0}}, + {"afWorkgroupMemory", SpvWord{256}}, + {"cdSubgroupImageBlockIOINTEL", SpvWord{5570}}, + {"boSideEffectsINTEL", SpvWord{5608}}, + {"anVulkan", SpvWord{3}}, + {"cdRayTraversalPrimitiveCullingKHR", SpvWord{4478}}, + {"cdGroupNonUniformArithmetic", SpvWord{63}}, + {"bgRTP", SpvWord{2}}, + {"cdMeshShadingNV", SpvWord{5266}}, + {"bfUnormShort555", SpvWord{5}}, + {"ciMatrixResultSignedComponentsKHR", SpvWord{8}}, + {"bdUnknown", SpvWord{0}}, + {"amPhysicalStorageBuffer64EXT", SpvWord{5348}}, + {"boDontStaticallyCoalesceINTEL", SpvWord{5901}}, + {"bpSubgroupLeMask", SpvWord{4419}}, + {"cdAtomicFloat64AddEXT", SpvWord{6034}}, + {"cdRoundingModeRTE", SpvWord{4467}}, + {"aoDerivativeGroupQuadsNV", SpvWord{5289}}, + {"boColMajor", SpvWord{5}}, + {"apIncomingRayPayloadKHR", SpvWord{5342}}, + {"afRelease", SpvWord{4}}, + {"cjRowMajorKHR", SpvWord{0}}, + {"afCrossWorkgroupMemory", SpvWord{512}}, + {"cdStoragePushConstant16", SpvWord{4435}}, + {"alFragment", SpvWord{4}}, + {"boMMHostInterfaceReadWriteModeINTEL", SpvWord{6180}}, + {"bbClampToEdge", SpvWord{1}}, + {"bpGlobalOffset", SpvWord{33}}, + {"aiNoOpaqueKHR", SpvWord{2}}, + {"baSubpassData", SpvWord{6}}, + {"cdImageMipmap", SpvWord{15}}, + {"bpSubgroupGeMaskKHR", SpvWord{4417}}, + {"cdImageFootprintNV", SpvWord{5282}}, + {"cdGenericPointer", SpvWord{38}}, + {"bdR32ui", SpvWord{33}}, + {"bfUnormInt101010", SpvWord{6}}, + {"bpPrimitiveCountNV", SpvWord{5275}}, + {"boRowMajor", SpvWord{4}}, + {"cdTileImageColorReadAccessEXT", SpvWord{4166}}, + {"ckMatrixAccumulatorKHR", SpvWord{2}}, + {"apIncomingCallableDataNV", SpvWord{5329}}, + {"boMediaBlockIOINTEL", SpvWord{6140}}, + {"agMakePointerAvailableKHR", SpvWord{8}}, + {"adSpeculatedIterationsINTEL", SpvWord{4194304}}, + {"bpRayGeometryIndexKHR", SpvWord{5352}}, + {"apPhysicalStorageBufferEXT", SpvWord{5349}}, + {"bpRayTmaxNV", SpvWord{5326}}, + {"bdR32i", SpvWord{24}}, + {"bdRgba8", SpvWord{4}}, + {"bpWorldRayDirectionKHR", SpvWord{5322}}, + {"adUnroll", SpvWord{1}}, + {"bdRg16f", SpvWord{7}}, + {"boPassthroughNV", SpvWord{5250}}, + {"cdSampleMaskPostDepthCoverage", SpvWord{4447}}, + {"bdR8ui", SpvWord{39}}, + {"cdUniformAndStorageBuffer8BitAccess", SpvWord{4449}}, + {"cdRuntimeAlignedAttributeINTEL", SpvWord{5939}}, + {"cdUniformBufferArrayNonUniformIndexingEXT", SpvWord{5306}}, + {"bpDeviceIndex", SpvWord{4438}}, + {"bpSubgroupLeMaskKHR", SpvWord{4419}}, + {"caInvocation", SpvWord{4}}, + {"bpTessLevelInner", SpvWord{12}}, + {"cdFloat16Buffer", SpvWord{8}}, + {"bpCullPrimitiveEXT", SpvWord{5299}}, + {"boPerVertexKHR", SpvWord{5285}}, + {"boExplicitInterpAMD", SpvWord{4999}}, + {"bpShadingRateKHR", SpvWord{4444}}, + {"agAligned", SpvWord{2}}, + {"boGLSLPacked", SpvWord{9}}, + {"aiCullNoOpaqueKHR", SpvWord{128}}, + {"boFunctionDenormModeINTEL", SpvWord{5823}}, + {"bbClamp", SpvWord{2}}, + {"bmReadWrite", SpvWord{2}}, + {"aaNontemporal", SpvWord{16384}}, + {"apOutput", SpvWord{3}}, + {"bpSMIDNV", SpvWord{5377}}, + {"cdShadingRateNV", SpvWord{5291}}, + {"apFunction", SpvWord{7}}, + {"baTileImageDataEXT", SpvWord{4173}}, + {"boNoSignedWrap", SpvWord{4469}}, + {"cdBlockingPipesINTEL", SpvWord{5945}}, + {"cdImageQuery", SpvWord{50}}, + {"aoVertexOrderCcw", SpvWord{5}}, + {"boLatencyControlLabelINTEL", SpvWord{6172}}, + {"agMakePointerVisibleKHR", SpvWord{16}}, + {"cdStorageTexelBufferArrayDynamicIndexing", SpvWord{5305}}, + {"beRx", SpvWord{10}}, + {"bdRgba16", SpvWord{10}}, + {"biRND", SpvWord{2}}, + {"boArrayStride", SpvWord{6}}, + {"cdFPGABufferLocationINTEL", SpvWord{5920}}, + {"beRG", SpvWord{2}}, + {"aoInputTrianglesAdjacency", SpvWord{23}}, + {"bdRgba8ui", SpvWord{32}}, + {"agAliasScopeINTELMask", SpvWord{65536}}, + {"bpSubgroupSize", SpvWord{36}}, + {"boStackCallINTEL", SpvWord{5627}}, + {"cbPartitionedExclusiveScanNV", SpvWord{8}}, + {"cdUniformAndStorageBuffer16BitAccess", SpvWord{4434}}, + {"aoSharedLocalMemorySizeINTEL", SpvWord{5618}}, + {"bfUnsignedInt32", SpvWord{12}}, + {"cdStorageImageArrayNonUniformIndexingEXT", SpvWord{5309}}, + {"alClosestHitNV", SpvWord{5316}}, + {"cdStorageInputOutput16", SpvWord{4436}}, + {"aoTriangles", SpvWord{22}}, + {"akOpenCL_C", SpvWord{3}}, + {"cdExpectAssumeKHR", SpvWord{5629}}, + {"cdFPGAClusterAttributesINTEL", SpvWord{5904}}, + {"aoDepthGreater", SpvWord{14}}, + {"boMaxByteOffset", SpvWord{45}}, + {"cdFragmentMaskAMD", SpvWord{5010}}, + {"bpLayer", SpvWord{9}}, + {"cdImage1D", SpvWord{44}}, + {"bdRgb10a2ui", SpvWord{34}}, + {"bdR16i", SpvWord{28}}, + {"aaNonPrivateTexelKHR", SpvWord{1024}}, + {"cjColumnMajorKHR", SpvWord{1}}, + {"bpWorldRayOriginNV", SpvWord{5321}}, + {"bpCullDistancePerViewNV", SpvWord{5278}}, + {"cdInputAttachmentArrayNonUniformIndexing", SpvWord{5310}}, + {"bfSnormInt8", SpvWord{0}}, + {"cdSubgroupShuffleINTEL", SpvWord{5568}}, + {"bhFlushToZero", SpvWord{1}}, + {"abAllowRecip", SpvWord{8}}, + {"cdSampleMaskOverrideCoverageNV", SpvWord{5249}}, + {"adPeelCount", SpvWord{128}}, + {"boPerTaskNV", SpvWord{5273}}, + {"cdKernelAttributesINTEL", SpvWord{5892}}, + {"bpFragCoord", SpvWord{15}}, + {"boBurstCoalesceINTEL", SpvWord{5899}}, + {"bpBaryCoordNV", SpvWord{5286}}, + {"boPrefetchINTEL", SpvWord{5902}}, + {"bpInvocationsPerPixelNV", SpvWord{5293}}, + {"bpTaskCountNV", SpvWord{5274}}, + {"cdLongConstantCompositeINTEL", SpvWord{6089}}, + {"bpClipDistancePerViewNV", SpvWord{5277}}, + {"bpEnqueuedWorkgroupSize", SpvWord{32}}, + {"cdTileImageDepthReadAccessEXT", SpvWord{4167}}, + {"bpSubgroupEqMask", SpvWord{4416}}, + {"aoLocalSizeHint", SpvWord{18}}, + {"cdVector16", SpvWord{7}}, + {"bdRgba16i", SpvWord{22}}, + {"apHostOnlyINTEL", SpvWord{5937}}, + {"bpHitKindNV", SpvWord{5333}}, + {"aoLocalSizeHintId", SpvWord{39}}, + {"alCallableNV", SpvWord{5318}}, + {"beRGBA", SpvWord{5}}, + {"boOffset", SpvWord{35}}, + {"agMakePointerVisible", SpvWord{16}}, + {"cdSampled1D", SpvWord{43}}, + {"bpWarpsPerSMNV", SpvWord{5374}}, + {"beA", SpvWord{1}}, + {"acDontFlatten", SpvWord{2}}, + {"cgRayQueryCandidateIntersectionTriangleKHR", SpvWord{0}}, + {"cdComputeDerivativeGroupLinearNV", SpvWord{5350}}, + {"cbInclusiveScan", SpvWord{1}}, + {"boNoUnsignedWrap", SpvWord{4470}}, + {"aoStencilRefUnchangedBackAMD", SpvWord{5082}}, + {"bnNoWrite", SpvWord{6}}, + {"boUniformId", SpvWord{27}}, + {"cdAtomicFloat32MinMaxEXT", SpvWord{5612}}, + {"aoDenormPreserve", SpvWord{4459}}, + {"aaOffset", SpvWord{16}}, + {"aeConst", SpvWord{8}}, + {"cdIntegerFunctions2INTEL", SpvWord{5584}}, + {"cdRoundToInfinityINTEL", SpvWord{5582}}, + {"aiNoneKHR", SpvWord{0}}, + {"boReferencedIndirectlyINTEL", SpvWord{5602}}, + {"alVertex", SpvWord{0}}, + {"cdFragmentDensityEXT", SpvWord{5291}}, + {"bpRayTminKHR", SpvWord{5325}}, + {"aoStreamingInterfaceINTEL", SpvWord{6154}}, + {"aoPixelInterlockUnorderedEXT", SpvWord{5367}}, + {"cdRayTracingProvisionalKHR", SpvWord{5353}}, + {"cdFPGAKernelAttributesINTEL", SpvWord{5897}}, + {"bcNearest", SpvWord{0}}, + {"alAnyHitKHR", SpvWord{5315}}, + {"cdKernel", SpvWord{6}}, + {"anVulkanKHR", SpvWord{3}}, + {"akHLSL", SpvWord{5}}, + {"aoSignedZeroInfNanPreserve", SpvWord{4461}}, + {"aoEarlyFragmentTests", SpvWord{9}}, + {"boCPacked", SpvWord{10}}, + {"cdImageBasic", SpvWord{13}}, + {"bjIEEE", SpvWord{0}}, + {"apUniform", SpvWord{2}}, + {"aoPixelCenterInteger", SpvWord{6}}, + {"beBGRA", SpvWord{6}}, + {"cdRayQueryProvisionalKHR", SpvWord{4471}}, + {"boSIMTCallINTEL", SpvWord{5599}}, + {"alTaskNV", SpvWord{5267}}, + {"bdRgba16ui", SpvWord{31}}, + {"ciNoneKHR", SpvWord{0}}, + {"cdGroupNonUniformQuad", SpvWord{68}}, + {"akSYCL", SpvWord{7}}, + {"cdCullDistance", SpvWord{33}}, + {"boConstant", SpvWord{22}}, + {"adDependencyLength", SpvWord{8}}, + {"adMaxReinvocationDelayINTEL", SpvWord{33554432}}, + {"afAcquireRelease", SpvWord{8}}, + {"cdLinkage", SpvWord{5}}, + {"alRayGenerationKHR", SpvWord{5313}}, + {"cdBitInstructions", SpvWord{6025}}, + {"bfSignedInt32", SpvWord{9}}, + {"cdClipDistance", SpvWord{32}}, + {"aaZeroExtend", SpvWord{8192}}, + {"bpPointCoord", SpvWord{16}}, + {"cdStorageImageMultisample", SpvWord{27}}, + {"apGeneric", SpvWord{8}}, + {"bpPrimitiveIndicesNV", SpvWord{5276}}, + {"boGlobalVariableOffsetINTEL", SpvWord{5628}}, + {"aoEarlyAndLateFragmentTestsAMD", SpvWord{5017}}, + {"bgRTZ", SpvWord{1}}, + {"cdGeometry", SpvWord{2}}, + {"bdRgba8i", SpvWord{23}}, + {"bpCoreCountARM", SpvWord{4161}}, + {"aaMakeTexelVisible", SpvWord{512}}, + {"apRayPayloadNV", SpvWord{5338}}, + {"aaVolatileTexel", SpvWord{2048}}, + {"agNone", SpvWord{0}}, + {"bpPrimitiveTriangleIndicesEXT", SpvWord{5296}}, + {"amPhysical64", SpvWord{2}}, + {"bpSampleId", SpvWord{18}}, + {"acNone", SpvWord{0}}, + {"beRA", SpvWord{3}}, + {"afRelaxed", SpvWord{0}}, + {"bfUnsignedIntRaw10EXT", SpvWord{19}}, + {"boStallEnableINTEL", SpvWord{5905}}, + {"aoRoundingModeRTPINTEL", SpvWord{5620}}, + {"cdPerViewAttributesNV", SpvWord{5260}}, + {"bpWorldRayOriginKHR", SpvWord{5321}}, + {"cdShaderInvocationReorderNV", SpvWord{5383}}, + {"cdShaderStereoViewNV", SpvWord{5259}}, + {"cdSubgroupVoteKHR", SpvWord{4431}}, + {"adPipelineEnableINTEL", SpvWord{524288}}, + {"apAtomicCounter", SpvWord{10}}, + {"aoSpacingFractionalEven", SpvWord{2}}, + {"bkSAT_ZERO", SpvWord{2}}, + {"apCallableDataNV", SpvWord{5328}}, + {"cdBFloat16ConversionINTEL", SpvWord{6115}}, + {"aoStencilRefUnchangedFrontAMD", SpvWord{5079}}, + {"bpIncomingRayFlagsNV", SpvWord{5351}}, + {"cdShaderViewportIndexLayerNV", SpvWord{5254}}, + {"ccWaitKernel", SpvWord{1}}, + {"cfRayQueryCommittedIntersectionGeneratedKHR", SpvWord{2}}, + {"bpHitTriangleVertexPositionsKHR", SpvWord{5335}}, + {"bjALT", SpvWord{1}}, + {"cdFragmentShadingRateKHR", SpvWord{4422}}, + {"cbPartitionedReduceNV", SpvWord{6}}, + {"bpSamplePosition", SpvWord{19}}, + {"alCallableKHR", SpvWord{5318}}, + {"ckMatrixBKHR", SpvWord{1}}, + {"cdGeometryPointSize", SpvWord{24}}, + {"cdFragmentShaderShadingRateInterlockEXT", SpvWord{5372}}, + {"boBlockMatchTextureQCOM", SpvWord{4488}}, + {"boMemoryINTEL", SpvWord{5826}}, + {"cdGroups", SpvWord{18}}, + {"bpPrimitiveLineIndicesEXT", SpvWord{5295}}, + {"bnZext", SpvWord{0}}, + {"cdPipes", SpvWord{17}}, + {"bpVertexId", SpvWord{5}}, + {"cdAtomicFloat32AddEXT", SpvWord{6033}}, + {"cdAtomicStorage", SpvWord{21}}, + {"cdDeviceEnqueue", SpvWord{19}}, + {"apHitObjectAttributeNV", SpvWord{5385}}, + {"adNoFusionINTEL", SpvWord{8388608}}, + {"cdShaderViewportIndexLayerEXT", SpvWord{5254}}, + {"amPhysical32", SpvWord{1}}, + {"aiCullBackFacingTrianglesKHR", SpvWord{16}}, + {"bpCoreIDARM", SpvWord{4160}}, + {"caQueueFamilyKHR", SpvWord{5}}, + {"apDeviceOnlyINTEL", SpvWord{5936}}, + {"cdImageReadWriteLodAMD", SpvWord{5015}}, + {"boLatencyControlConstraintINTEL", SpvWord{6173}}, + {"aoSubgroupsPerWorkgroupId", SpvWord{37}}, + {"bpInstanceCustomIndexKHR", SpvWord{5327}}, + {"aoNonCoherentDepthAttachmentReadEXT", SpvWord{4170}}, + {"bfUnsignedInt8", SpvWord{10}}, + {"bmWriteOnly", SpvWord{1}}, + {"boNoPerspective", SpvWord{13}}, + {"aoOutputLinesEXT", SpvWord{5269}}, + {"boNoAliasINTEL", SpvWord{5915}}, + {"cdDemoteToHelperInvocation", SpvWord{5379}}, + {"adIterationMultiple", SpvWord{64}}, + {"cdCooperativeMatrixKHR", SpvWord{6022}}, + {"cdDotProductInput4x8BitPacked", SpvWord{6018}}, + {"bpGlobalLinearId", SpvWord{34}}, + {"apIncomingCallableDataKHR", SpvWord{5329}}, + {"cdDebugInfoModuleINTEL", SpvWord{6114}}, + {"aaBias", SpvWord{1}}, + {"bfUnormInt24", SpvWord{15}}, + {"aoInvocations", SpvWord{0}}, + {"apIncomingRayPayloadNV", SpvWord{5342}}, + {"aiForceOpacityMicromap2StateEXT", SpvWord{1024}}, + {"ciMatrixCSignedComponentsKHR", SpvWord{4}}, + {"cdBindlessTextureNV", SpvWord{5390}}, + {"cdCoreBuiltinsARM", SpvWord{4165}}, + {"cdFPGAArgumentInterfacesINTEL", SpvWord{6174}}, + {"boInitiationIntervalINTEL", SpvWord{5917}}, + {"akHERO_C", SpvWord{8}}, + {"boAliasedPointerEXT", SpvWord{5356}}, + {"afUniformMemory", SpvWord{64}}, + {"apInput", SpvWord{1}}, + {"bpObjectToWorldKHR", SpvWord{5330}}, + {"bdRgba8Snorm", SpvWord{5}}, + {"boRegisterMapKernelArgumentINTEL", SpvWord{6176}}, + {"bpDrawIndex", SpvWord{4426}}, + {"boMMHostInterfaceWaitRequestINTEL", SpvWord{6182}}, + {"boPipelineEnableINTEL", SpvWord{5919}}, + {"cdFragmentShaderPixelInterlockEXT", SpvWord{5378}}, + {"bfSignedInt8", SpvWord{7}}, + {"aaGrad", SpvWord{4}}, + {"aoOutputPrimitivesEXT", SpvWord{5270}}, + {"besBGRA", SpvWord{18}}, + {"bpViewportIndex", SpvWord{10}}, + {"afSequentiallyConsistent", SpvWord{16}}, + {"alRayGenerationNV", SpvWord{5313}}, + {"abNone", SpvWord{0}}, + {"alMeshNV", SpvWord{5268}}, + {"boConduitKernelArgumentINTEL", SpvWord{6175}}, + {"bbRepeat", SpvWord{3}}, + {"bbNone", SpvWord{0}}, + {"adMaxInterleavingINTEL", SpvWord{2097152}}, + {"cdInputAttachmentArrayDynamicIndexing", SpvWord{5303}}, + {"cdSubgroupImageMediaBlockIOINTEL", SpvWord{5579}}, + {"apShaderRecordBufferNV", SpvWord{5343}}, + {"cdDenormFlushToZero", SpvWord{4465}}, + {"ahCmdExecTime", SpvWord{1}}, + {"cdStorageImageWriteWithoutFormat", SpvWord{56}}, + {"cdPipeStorage", SpvWord{60}}, + {"boSinglepumpINTEL", SpvWord{5830}}, + {"cdUniformTexelBufferArrayNonUniformIndexingEXT", SpvWord{5311}}, + {"beDepth", SpvWord{13}}, + {"boSaturatedConversion", SpvWord{28}}, + {"cdDerivativeControl", SpvWord{51}}, + {"cdRayTracingMotionBlurNV", SpvWord{5341}}, + {"apCrossWorkgroup", SpvWord{5}}, + {"bpSubgroupGtMask", SpvWord{4418}}, + {"bpBaryCoordSmoothAMD", SpvWord{4995}}, + {"bpLaunchIdKHR", SpvWord{5319}}, + {"cfRayQueryCommittedIntersectionNoneKHR", SpvWord{0}}, + {"cbExclusiveScan", SpvWord{2}}, + {"aaConstOffset", SpvWord{8}}, + {"cdGeometryShaderPassthroughNV", SpvWord{5251}}, + {"boForcePow2DepthINTEL", SpvWord{5836}}, + {"bnSext", SpvWord{1}}, + {"bpBaryCoordPullModelAMD", SpvWord{4998}}, + {"agNonPrivatePointerKHR", SpvWord{32}}, + {"biRND_CONV_ODD", SpvWord{7}}, + {"cdStorageImageArrayNonUniformIndexing", SpvWord{5309}}, + {"boIOPipeStorageINTEL", SpvWord{5944}}, + {"apPrivate", SpvWord{6}}, + {"cdFPGADSPControlINTEL", SpvWord{5908}}, + {"bmReadOnly", SpvWord{0}}, + {"cdVariablePointers", SpvWord{4442}}, + {"bpTessCoord", SpvWord{13}}, + {"ahNone", SpvWord{0}}, + {"bpNumSubgroups", SpvWord{38}}, + {"bkSAT_SYM", SpvWord{3}}, + {"adDontUnroll", SpvWord{2}}, + {"caCrossDevice", SpvWord{0}}, + {"cdShaderViewportMaskNV", SpvWord{5255}}, + {"cdGroupNonUniformVote", SpvWord{62}}, + {"cdAddresses", SpvWord{4}}, + {"afOutputMemoryKHR", SpvWord{4096}}, + {"cdMatrix", SpvWord{0}}, + {"akNZSL", SpvWord{9}}, + {"cdRayQueryPositionFetchKHR", SpvWord{5391}}, + {"biRND_INF", SpvWord{4}}, + {"cdSampledImageArrayDynamicIndexing", SpvWord{29}}, + {"adDependencyInfinite", SpvWord{4}}, + {"aiCullOpaqueKHR", SpvWord{64}}, + {"cdFPGAInvocationPipeliningAttributesINTEL", SpvWord{5916}}, + {"abAllowReassocINTEL", SpvWord{131072}}, + {"cdDrawParameters", SpvWord{4427}}, + {"boPerViewNV", SpvWord{5272}}, + {"aoRoundingModeRTZ", SpvWord{4463}}, + {"afMakeAvailableKHR", SpvWord{8192}}, + {"bpWorkDim", SpvWord{30}}, + {"agMakePointerAvailable", SpvWord{8}}, + {"bpSubgroupGtMaskKHR", SpvWord{4418}}, + {"aiSkipAABBsKHR", SpvWord{512}}, + {"bdRgba16f", SpvWord{2}}, + {"boMMHostInterfaceAddressWidthINTEL", SpvWord{6177}}, + {"afMakeVisibleKHR", SpvWord{16384}}, + {"beABGR", SpvWord{19}}, + {"cdInterpolationFunction", SpvWord{52}}, + {"aoStencilRefReplacingEXT", SpvWord{5027}}, + {"bfHalfFloat", SpvWord{13}}, + {"cdRuntimeDescriptorArrayEXT", SpvWord{5302}}, + {"apHitAttributeNV", SpvWord{5339}}, + {"bpBaryCoordNoPerspNV", SpvWord{5287}}, + {"cdUniformDecoration", SpvWord{71}}, + {"afNone", SpvWord{0}}, + {"bdR8Snorm", SpvWord{20}}, + {"bpWorldRayDirectionNV", SpvWord{5322}}, + {"cdDotProductInputAll", SpvWord{6016}}, + {"bpLaunchSizeNV", SpvWord{5320}}, + {"boSpecId", SpvWord{1}}, + {"cdSampledRect", SpvWord{37}}, + {"cdStorageBufferArrayNonUniformIndexingEXT", SpvWord{5308}}, + {"cdFPGALatencyControlINTEL", SpvWord{6171}}, + {"bgRTE", SpvWord{0}}, + {"cdLiteralSampler", SpvWord{20}}, + {"apRayPayloadKHR", SpvWord{5338}}, + {"cdSampledBuffer", SpvWord{46}}, + {"cdWorkgroupMemoryExplicitLayout16BitAccessKHR", SpvWord{4430}}, + {"cdGroupNonUniformPartitionedNV", SpvWord{5297}}, + {"boAliasScopeINTEL", SpvWord{5914}}, + {"boHlslSemanticGOOGLE", SpvWord{5635}}, + {"boMaxReplicatesINTEL", SpvWord{5832}}, + {"bfUnsignedIntRaw12EXT", SpvWord{20}}, + {"aoInputLinesAdjacency", SpvWord{21}}, + {"aoPointMode", SpvWord{10}}, + {"cdDotProductInput4x8BitPackedKHR", SpvWord{6018}}, + {"cdGroupNonUniform", SpvWord{61}}, + {"afAcquire", SpvWord{2}}, + {"boBoundImageNV", SpvWord{5401}}, + {"aoNonCoherentColorAttachmentReadEXT", SpvWord{4169}}, + {"apCodeSectionINTEL", SpvWord{5605}}, + {"apHitAttributeKHR", SpvWord{5339}}, + {"boPatch", SpvWord{15}}, + {"abAllowContractFastINTEL", SpvWord{65536}}, + {"boFuncParamAttr", SpvWord{38}}, + {"bdRg8i", SpvWord{27}}, + {"boRegisterINTEL", SpvWord{5825}}, + {"aoStencilRefLessFrontAMD", SpvWord{5081}}, + {"boMergeINTEL", SpvWord{5834}}, + {"boClobberINTEL", SpvWord{5607}}, + {"bpCurrentRayTimeNV", SpvWord{5334}}, + {"boNonUniformEXT", SpvWord{5300}}, + {"adNone", SpvWord{0}}, + {"boSingleElementVectorINTEL", SpvWord{6085}}, + {"akOpenCL_CPP", SpvWord{4}}, + {"cdFPMaxErrorINTEL", SpvWord{6169}}, + {"bpLaunchSizeKHR", SpvWord{5320}}, + {"cdStorageUniform16", SpvWord{4434}}, + {"beIntensity", SpvWord{8}}, + {"bpLaunchIdNV", SpvWord{5319}}, + {"chPackedVectorFormat4x8Bit", SpvWord{0}}, + {"cdSampleRateShading", SpvWord{35}}, + {"cdStoragePushConstant8", SpvWord{4450}}, + {"cdTextureBoxFilterQCOM", SpvWord{4485}}, + {"bpViewportMaskPerViewNV", SpvWord{5262}}, + {"cdGroupNonUniformBallot", SpvWord{64}}, + {"ajVertical4Pixels", SpvWord{2}}, + {"cdTextureSampleWeightedQCOM", SpvWord{4484}}, + {"cdImageGatherExtended", SpvWord{25}}, + {"cdAsmINTEL", SpvWord{5606}}, + {"boNonReadable", SpvWord{25}}, + {"boBuiltIn", SpvWord{11}}, + {"bpHitKindKHR", SpvWord{5333}}, + {"aoRoundingModeRTNINTEL", SpvWord{5621}}, + {"cdWorkgroupMemoryExplicitLayoutKHR", SpvWord{4428}}, + {"caQueueFamily", SpvWord{5}}, + {"beDepthStencil", SpvWord{14}}, + {"aoOriginLowerLeft", SpvWord{8}}, + {"cdUniformTexelBufferArrayNonUniformIndexing", SpvWord{5311}}, + {"alClosestHitKHR", SpvWord{5316}}, + {"biTRN_ZERO", SpvWord{1}}, + {"aaLod", SpvWord{2}}, + {"cdUniformBufferArrayDynamicIndexing", SpvWord{28}}, + {"boSimpleDualPortINTEL", SpvWord{5833}}, + {"ceRayQueryCandidateIntersectionKHR", SpvWord{0}}, + {"cdAtomicFloat16AddEXT", SpvWord{6095}}, + {"beRGx", SpvWord{11}}, + {"bpBaryCoordNoPerspSampleAMD", SpvWord{4994}}, + {"afMakeVisible", SpvWord{16384}}, + {"ciSaturatingAccumulationKHR", SpvWord{16}}, + {"cdDotProductInput4x8BitKHR", SpvWord{6017}}, + {"cdNamedBarrier", SpvWord{59}}, + {"boLinkageAttributes", SpvWord{41}}, + {"caWorkgroup", SpvWord{2}}, + {"apTileImageEXT", SpvWord{4172}}, + {"boCacheSizeINTEL", SpvWord{5900}}, + {"beRGB", SpvWord{4}}, + {"boMMHostInterfaceLatencyINTEL", SpvWord{6179}}, + {"boNoContraction", SpvWord{42}}, + {"aoRegisterMapInterfaceINTEL", SpvWord{6160}}, + {"ceRayQueryCommittedIntersectionKHR", SpvWord{1}}, + {"cdFPGAMemoryAttributesINTEL", SpvWord{5824}}, + {"bfSnormInt16", SpvWord{1}}, + {"bnRuntimeAlignedINTEL", SpvWord{5940}}, + {"bpGlobalInvocationId", SpvWord{28}}, + {"cdImageReadWrite", SpvWord{14}}, + {"bpInstanceCustomIndexNV", SpvWord{5327}}, + {"bpSubgroupMaxSize", SpvWord{37}}, + {"cdVectorComputeINTEL", SpvWord{5617}}, + {"beR", SpvWord{0}}, + {"bhPreserve", SpvWord{0}}, + {"cdSubgroupDispatch", SpvWord{58}}, + {"apTaskPayloadWorkgroupEXT", SpvWord{5402}}, + {"bdRg32ui", SpvWord{35}}, + {"alMissNV", SpvWord{5317}}, + {"aoPixelInterlockOrderedEXT", SpvWord{5366}}, + {"cdDenormPreserve", SpvWord{4464}}, + {"aeOptNoneINTEL", SpvWord{65536}}, + {"cdPhysicalStorageBufferAddresses", SpvWord{5347}}, + {"bdR64i", SpvWord{41}}, + {"boNumbanksINTEL", SpvWord{5827}}, + {"cdFragmentShaderSampleInterlockEXT", SpvWord{5363}}, + {"cdOptNoneINTEL", SpvWord{6094}}, + {"aiSkipTrianglesKHR", SpvWord{256}}, + {"cdStorageTexelBufferArrayNonUniformIndexing", SpvWord{5312}}, + {"beRGBx", SpvWord{12}}, + {"bpIncomingRayFlagsKHR", SpvWord{5351}}, + {"aoStencilRefGreaterBackAMD", SpvWord{5083}}, + {"boMMHostInterfaceMaxBurstINTEL", SpvWord{6181}}, + {"aoFloatingPointModeIEEEINTEL", SpvWord{5623}}, + {"alMeshEXT", SpvWord{5365}}, + {"cdShaderLayer", SpvWord{69}}, + {"cdFPGAMemoryAccessesINTEL", SpvWord{5898}}, + {"bpSecondaryViewportMaskNV", SpvWord{5258}}, + {"cdArbitraryPrecisionIntegersINTEL", SpvWord{5844}}, + {"ccWaitWorkGroup", SpvWord{2}}, + {"aoOutputLinesNV", SpvWord{5269}}, + {"aoOutputTriangleStrip", SpvWord{29}}, + {"baRect", SpvWord{4}}, + {"bpFragStencilRefEXT", SpvWord{5014}}, + {"blLinkOnceODR", SpvWord{2}}, + {"aoLocalSizeId", SpvWord{38}}, + {"abNSZ", SpvWord{4}}, + {"bdRg16i", SpvWord{26}}, + {"boMaxConcurrencyINTEL", SpvWord{5918}}, + {"akESSL", SpvWord{1}}, + {"caSubgroup", SpvWord{3}}, + {"bpFrontFacing", SpvWord{17}}, + {"boWeightTextureQCOM", SpvWord{4487}}, + {"aoNoGlobalOffsetINTEL", SpvWord{5895}}, + {"bpViewportMaskNV", SpvWord{5253}}, + {"bdRgb10A2", SpvWord{11}}, + {"aaNonPrivateTexel", SpvWord{1024}}, + {"cdUniformTexelBufferArrayDynamicIndexing", SpvWord{5304}}, + {"bpViewIndex", SpvWord{4440}}, + {"afAtomicCounterMemory", SpvWord{1024}}, + {"bpGlobalSize", SpvWord{31}}, + {"bpMeshViewCountNV", SpvWord{5280}}, + {"cdImageBuffer", SpvWord{47}}, + {"alGeometry", SpvWord{3}}, + {"agVolatile", SpvWord{1}}, + {"bdRg8", SpvWord{13}}, + {"cdIndirectReferencesINTEL", SpvWord{5604}}, + {"biRND_MIN_INF", SpvWord{5}}, + {"bpBaryCoordSmoothSampleAMD", SpvWord{4997}}, + {"cdVulkanMemoryModelKHR", SpvWord{5345}}, + {"aoNamedBarrierCountINTEL", SpvWord{6417}}, + {"cdShaderNonUniform", SpvWord{5301}}, + {"adMaxIterations", SpvWord{32}}, + {"aaMinLod", SpvWord{128}}, + {"boFPFastMathMode", SpvWord{40}}, + {"bpFullyCoveredEXT", SpvWord{5264}}, + {"bpClipDistance", SpvWord{3}}, + {"cdArbitraryPrecisionFixedPointINTEL", SpvWord{5922}}, + {"bpBaseInstance", SpvWord{4425}}, + {"cdMultiView", SpvWord{4439}}, + {"bpInstanceIndex", SpvWord{43}}, + {"bdRg8ui", SpvWord{37}}, + {"aoMaxWorkDimINTEL", SpvWord{5894}}, + {"cdInputAttachmentArrayNonUniformIndexingEXT", SpvWord{5310}}, + {"amPhysicalStorageBuffer64", SpvWord{5348}}, + {"aaMakeTexelVisibleKHR", SpvWord{512}}, + {"cdUniformTexelBufferArrayDynamicIndexingEXT", SpvWord{5304}}, + {"besRGB", SpvWord{15}}, + {"aaNone", SpvWord{0}}, + {"alGLCompute", SpvWord{5}}, + {"bbRepeatMirrored", SpvWord{4}}, + {"baBuffer", SpvWord{5}}, + {"cdGeometryStreams", SpvWord{54}}, + {"boDescriptorSet", SpvWord{34}}, + {"aoLocalSize", SpvWord{17}}, + {"cdShaderViewportIndex", SpvWord{70}}, + {"cdStorageTexelBufferArrayNonUniformIndexingEXT", SpvWord{5312}}, + {"boBankwidthINTEL", SpvWord{5828}}, + {"bfFloat", SpvWord{14}}, + {"beARGB", SpvWord{7}}, + {"cdStorageImageReadWithoutFormat", SpvWord{55}}, + {"bpCoreMaxIDARM", SpvWord{4162}}, + {"cdRayCullMaskKHR", SpvWord{6020}}, + {"cdShaderSMBuiltinsNV", SpvWord{5373}}, + {"aiTerminateOnFirstHitKHR", SpvWord{4}}, + {"cdWorkgroupMemoryExplicitLayout8BitAccessKHR", SpvWord{4429}}, + {"bpWarpMaxIDARM", SpvWord{4164}}, + {"aoDepthUnchanged", SpvWord{16}}, + {"alTessellationEvaluation", SpvWord{2}}, + {"cdStorageBuffer16BitAccess", SpvWord{4433}}, + {"aoSampleInterlockUnorderedEXT", SpvWord{5369}}, + {"bpHitTNV", SpvWord{5332}}, + {"bdR16f", SpvWord{9}}, + {"aaMakeTexelAvailable", SpvWord{256}}, + {"aoDerivativeGroupLinearNV", SpvWord{5290}}, + {"apWorkgroup", SpvWord{4}}, + {"bnNoCapture", SpvWord{5}}, + {"cdFloat16ImageAMD", SpvWord{5008}}, + {"aoOutputTrianglesEXT", SpvWord{5298}}, + {"bfUnsignedInt16", SpvWord{11}}, + {"cdTessellation", SpvWord{3}}, + {"cdImageGatherBiasLodAMD", SpvWord{5009}}, + {"bpLocalInvocationId", SpvWord{27}}, + {"anGLSL450", SpvWord{1}}, + {"aoShadingRateInterlockUnorderedEXT", SpvWord{5371}}, + {"boStream", SpvWord{29}}, + {"boFPMaxErrorDecorationINTEL", SpvWord{6170}}, + {"cdCooperativeMatrixNV", SpvWord{5357}}, + {"cdInt64Atomics", SpvWord{12}}, + {"amLogical", SpvWord{0}}, + {"cdPhysicalStorageBufferAddressesEXT", SpvWord{5347}}, + {"alKernel", SpvWord{6}}, + {"cdTransformFeedback", SpvWord{53}}, + {"aoXfb", SpvWord{11}}, + {"aePure", SpvWord{4}}, + {"bpFragDepth", SpvWord{22}}, + {"ajVertical2Pixels", SpvWord{1}}, + {"aoInitializer", SpvWord{33}}, + {"bpBaryCoordNoPerspKHR", SpvWord{5287}}, + {"adPartialCount", SpvWord{256}}, + {"cdRayTracingPositionFetchKHR", SpvWord{5336}}, + {"cdAtomicFloat64MinMaxEXT", SpvWord{5613}}, + {"cfRayQueryCommittedIntersectionTriangleKHR", SpvWord{1}}, + {"aoInputPoints", SpvWord{19}}, + {"alAnyHitNV", SpvWord{5315}}, + {"cdTessellationPointSize", SpvWord{23}}, + {"aaOffsets", SpvWord{65536}}, + {"cdInt16", SpvWord{22}}, + {"cdRayTracingKHR", SpvWord{4479}}, + {"cdImageRect", SpvWord{36}}, + {"cdInt8", SpvWord{39}}, + {"bpObjectRayDirectionKHR", SpvWord{5324}}, + {"bpSubgroupId", SpvWord{40}}, + {"cdFragmentBarycentricNV", SpvWord{5284}}, + {"cdDotProductInputAllKHR", SpvWord{6016}}, + {"aoFloatingPointModeALTINTEL", SpvWord{5622}}, + {"cdMultiViewport", SpvWord{57}}, + {"boVectorComputeVariableINTEL", SpvWord{5624}}, + {"cdGroupUniformArithmeticKHR", SpvWord{6400}}, + {"bpMeshViewIndicesNV", SpvWord{5281}}, + {"cdFPFastMathModeINTEL", SpvWord{5837}}, + {"aoSpacingEqual", SpvWord{1}}, + {"bpPrimitivePointIndicesEXT", SpvWord{5294}}, + {"bpWorldToObjectKHR", SpvWord{5331}}, + {"boBinding", SpvWord{33}}, + {"cdGroupNonUniformClustered", SpvWord{67}}, + {"boUserSemantic", SpvWord{5635}}, + {"aoDepthLess", SpvWord{15}}, + {"adMinIterations", SpvWord{16}}, + }; + + static const auto hash = [](const UnownedStringSlice& str, UInt32 salt){ + UInt32 h = salt; + for (const char c : str) + h = (h * 0x01000193) ^ c; + return h % 944; + }; + + const auto i = hash(str, tableSalt[hash(str, 0)]); + if(str == words[i].first) + { + value = words[i].second; + return true; + } + else + { + return false; + } +} + +static bool lookupQualifiedEnum(const QualifiedEnumName& k, SpvWord& v) +{ + static_assert(sizeof(k.kind.index) == 1); + if(k.name.getLength() > 46) + return false; + char name[48]; + name[0] = char((k.kind.index >> 4) + 'a'); + name[1] = char((k.kind.index & 0xf) + 'a'); + memcpy(name+2, k.name.begin(), k.name.getLength()); + return lookupEnumWithHexPrefix(UnownedStringSlice(name, k.name.getLength() + 2), v); +} + +static bool getQualifiedEnumName(const QualifiedEnumValue& k, UnownedStringSlice& v) +{ + const auto& [k1, k2] = k; + switch(k1.index) + { + case 0: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Bias"}; return true; + case 2: v = UnownedStringSlice{"Lod"}; return true; + case 4: v = UnownedStringSlice{"Grad"}; return true; + case 8: v = UnownedStringSlice{"ConstOffset"}; return true; + case 16: v = UnownedStringSlice{"Offset"}; return true; + case 32: v = UnownedStringSlice{"ConstOffsets"}; return true; + case 64: v = UnownedStringSlice{"Sample"}; return true; + case 128: v = UnownedStringSlice{"MinLod"}; return true; + case 256: v = UnownedStringSlice{"MakeTexelAvailable"}; return true; + case 512: v = UnownedStringSlice{"MakeTexelVisible"}; return true; + case 1024: v = UnownedStringSlice{"NonPrivateTexel"}; return true; + case 2048: v = UnownedStringSlice{"VolatileTexel"}; return true; + case 4096: v = UnownedStringSlice{"SignExtend"}; return true; + case 8192: v = UnownedStringSlice{"ZeroExtend"}; return true; + case 16384: v = UnownedStringSlice{"Nontemporal"}; return true; + case 65536: v = UnownedStringSlice{"Offsets"}; return true; + default: return false; + } + case 1: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"NotNaN"}; return true; + case 2: v = UnownedStringSlice{"NotInf"}; return true; + case 4: v = UnownedStringSlice{"NSZ"}; return true; + case 8: v = UnownedStringSlice{"AllowRecip"}; return true; + case 16: v = UnownedStringSlice{"Fast"}; return true; + case 65536: v = UnownedStringSlice{"AllowContractFastINTEL"}; return true; + case 131072: v = UnownedStringSlice{"AllowReassocINTEL"}; return true; + default: return false; + } + case 2: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Flatten"}; return true; + case 2: v = UnownedStringSlice{"DontFlatten"}; return true; + default: return false; + } + case 3: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Unroll"}; return true; + case 2: v = UnownedStringSlice{"DontUnroll"}; return true; + case 4: v = UnownedStringSlice{"DependencyInfinite"}; return true; + case 8: v = UnownedStringSlice{"DependencyLength"}; return true; + case 16: v = UnownedStringSlice{"MinIterations"}; return true; + case 32: v = UnownedStringSlice{"MaxIterations"}; return true; + case 64: v = UnownedStringSlice{"IterationMultiple"}; return true; + case 128: v = UnownedStringSlice{"PeelCount"}; return true; + case 256: v = UnownedStringSlice{"PartialCount"}; return true; + case 65536: v = UnownedStringSlice{"InitiationIntervalINTEL"}; return true; + case 131072: v = UnownedStringSlice{"MaxConcurrencyINTEL"}; return true; + case 262144: v = UnownedStringSlice{"DependencyArrayINTEL"}; return true; + case 524288: v = UnownedStringSlice{"PipelineEnableINTEL"}; return true; + case 1048576: v = UnownedStringSlice{"LoopCoalesceINTEL"}; return true; + case 2097152: v = UnownedStringSlice{"MaxInterleavingINTEL"}; return true; + case 4194304: v = UnownedStringSlice{"SpeculatedIterationsINTEL"}; return true; + case 8388608: v = UnownedStringSlice{"NoFusionINTEL"}; return true; + case 16777216: v = UnownedStringSlice{"LoopCountINTEL"}; return true; + case 33554432: v = UnownedStringSlice{"MaxReinvocationDelayINTEL"}; return true; + default: return false; + } + case 4: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Inline"}; return true; + case 2: v = UnownedStringSlice{"DontInline"}; return true; + case 4: v = UnownedStringSlice{"Pure"}; return true; + case 8: v = UnownedStringSlice{"Const"}; return true; + case 65536: v = UnownedStringSlice{"OptNoneINTEL"}; return true; + default: return false; + } + case 5: + switch(k2) + { + case 0: v = UnownedStringSlice{"Relaxed"}; return true; + case 2: v = UnownedStringSlice{"Acquire"}; return true; + case 4: v = UnownedStringSlice{"Release"}; return true; + case 8: v = UnownedStringSlice{"AcquireRelease"}; return true; + case 16: v = UnownedStringSlice{"SequentiallyConsistent"}; return true; + case 64: v = UnownedStringSlice{"UniformMemory"}; return true; + case 128: v = UnownedStringSlice{"SubgroupMemory"}; return true; + case 256: v = UnownedStringSlice{"WorkgroupMemory"}; return true; + case 512: v = UnownedStringSlice{"CrossWorkgroupMemory"}; return true; + case 1024: v = UnownedStringSlice{"AtomicCounterMemory"}; return true; + case 2048: v = UnownedStringSlice{"ImageMemory"}; return true; + case 4096: v = UnownedStringSlice{"OutputMemory"}; return true; + case 8192: v = UnownedStringSlice{"MakeAvailable"}; return true; + case 16384: v = UnownedStringSlice{"MakeVisible"}; return true; + case 32768: v = UnownedStringSlice{"Volatile"}; return true; + default: return false; + } + case 6: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"Volatile"}; return true; + case 2: v = UnownedStringSlice{"Aligned"}; return true; + case 4: v = UnownedStringSlice{"Nontemporal"}; return true; + case 8: v = UnownedStringSlice{"MakePointerAvailable"}; return true; + case 16: v = UnownedStringSlice{"MakePointerVisible"}; return true; + case 32: v = UnownedStringSlice{"NonPrivatePointer"}; return true; + case 65536: v = UnownedStringSlice{"AliasScopeINTELMask"}; return true; + case 131072: v = UnownedStringSlice{"NoAliasINTELMask"}; return true; + default: return false; + } + case 7: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"CmdExecTime"}; return true; + default: return false; + } + case 8: + switch(k2) + { + case 0: v = UnownedStringSlice{"NoneKHR"}; return true; + case 1: v = UnownedStringSlice{"OpaqueKHR"}; return true; + case 2: v = UnownedStringSlice{"NoOpaqueKHR"}; return true; + case 4: v = UnownedStringSlice{"TerminateOnFirstHitKHR"}; return true; + case 8: v = UnownedStringSlice{"SkipClosestHitShaderKHR"}; return true; + case 16: v = UnownedStringSlice{"CullBackFacingTrianglesKHR"}; return true; + case 32: v = UnownedStringSlice{"CullFrontFacingTrianglesKHR"}; return true; + case 64: v = UnownedStringSlice{"CullOpaqueKHR"}; return true; + case 128: v = UnownedStringSlice{"CullNoOpaqueKHR"}; return true; + case 256: v = UnownedStringSlice{"SkipTrianglesKHR"}; return true; + case 512: v = UnownedStringSlice{"SkipAABBsKHR"}; return true; + case 1024: v = UnownedStringSlice{"ForceOpacityMicromap2StateEXT"}; return true; + default: return false; + } + case 9: + switch(k2) + { + case 1: v = UnownedStringSlice{"Vertical2Pixels"}; return true; + case 2: v = UnownedStringSlice{"Vertical4Pixels"}; return true; + case 4: v = UnownedStringSlice{"Horizontal2Pixels"}; return true; + case 8: v = UnownedStringSlice{"Horizontal4Pixels"}; return true; + default: return false; + } + case 10: + switch(k2) + { + case 0: v = UnownedStringSlice{"Unknown"}; return true; + case 1: v = UnownedStringSlice{"ESSL"}; return true; + case 2: v = UnownedStringSlice{"GLSL"}; return true; + case 3: v = UnownedStringSlice{"OpenCL_C"}; return true; + case 4: v = UnownedStringSlice{"OpenCL_CPP"}; return true; + case 5: v = UnownedStringSlice{"HLSL"}; return true; + case 6: v = UnownedStringSlice{"CPP_for_OpenCL"}; return true; + case 7: v = UnownedStringSlice{"SYCL"}; return true; + case 8: v = UnownedStringSlice{"HERO_C"}; return true; + case 9: v = UnownedStringSlice{"NZSL"}; return true; + case 10: v = UnownedStringSlice{"WGSL"}; return true; + default: return false; + } + case 11: + switch(k2) + { + case 0: v = UnownedStringSlice{"Vertex"}; return true; + case 1: v = UnownedStringSlice{"TessellationControl"}; return true; + case 2: v = UnownedStringSlice{"TessellationEvaluation"}; return true; + case 3: v = UnownedStringSlice{"Geometry"}; return true; + case 4: v = UnownedStringSlice{"Fragment"}; return true; + case 5: v = UnownedStringSlice{"GLCompute"}; return true; + case 6: v = UnownedStringSlice{"Kernel"}; return true; + case 5267: v = UnownedStringSlice{"TaskNV"}; return true; + case 5268: v = UnownedStringSlice{"MeshNV"}; return true; + case 5313: v = UnownedStringSlice{"RayGenerationNV"}; return true; + case 5314: v = UnownedStringSlice{"IntersectionNV"}; return true; + case 5315: v = UnownedStringSlice{"AnyHitNV"}; return true; + case 5316: v = UnownedStringSlice{"ClosestHitNV"}; return true; + case 5317: v = UnownedStringSlice{"MissNV"}; return true; + case 5318: v = UnownedStringSlice{"CallableNV"}; return true; + case 5364: v = UnownedStringSlice{"TaskEXT"}; return true; + case 5365: v = UnownedStringSlice{"MeshEXT"}; return true; + default: return false; + } + case 12: + switch(k2) + { + case 0: v = UnownedStringSlice{"Logical"}; return true; + case 1: v = UnownedStringSlice{"Physical32"}; return true; + case 2: v = UnownedStringSlice{"Physical64"}; return true; + case 5348: v = UnownedStringSlice{"PhysicalStorageBuffer64"}; return true; + default: return false; + } + case 13: + switch(k2) + { + case 0: v = UnownedStringSlice{"Simple"}; return true; + case 1: v = UnownedStringSlice{"GLSL450"}; return true; + case 2: v = UnownedStringSlice{"OpenCL"}; return true; + case 3: v = UnownedStringSlice{"Vulkan"}; return true; + default: return false; + } + case 14: + switch(k2) + { + case 0: v = UnownedStringSlice{"Invocations"}; return true; + case 1: v = UnownedStringSlice{"SpacingEqual"}; return true; + case 2: v = UnownedStringSlice{"SpacingFractionalEven"}; return true; + case 3: v = UnownedStringSlice{"SpacingFractionalOdd"}; return true; + case 4: v = UnownedStringSlice{"VertexOrderCw"}; return true; + case 5: v = UnownedStringSlice{"VertexOrderCcw"}; return true; + case 6: v = UnownedStringSlice{"PixelCenterInteger"}; return true; + case 7: v = UnownedStringSlice{"OriginUpperLeft"}; return true; + case 8: v = UnownedStringSlice{"OriginLowerLeft"}; return true; + case 9: v = UnownedStringSlice{"EarlyFragmentTests"}; return true; + case 10: v = UnownedStringSlice{"PointMode"}; return true; + case 11: v = UnownedStringSlice{"Xfb"}; return true; + case 12: v = UnownedStringSlice{"DepthReplacing"}; return true; + case 14: v = UnownedStringSlice{"DepthGreater"}; return true; + case 15: v = UnownedStringSlice{"DepthLess"}; return true; + case 16: v = UnownedStringSlice{"DepthUnchanged"}; return true; + case 17: v = UnownedStringSlice{"LocalSize"}; return true; + case 18: v = UnownedStringSlice{"LocalSizeHint"}; return true; + case 19: v = UnownedStringSlice{"InputPoints"}; return true; + case 20: v = UnownedStringSlice{"InputLines"}; return true; + case 21: v = UnownedStringSlice{"InputLinesAdjacency"}; return true; + case 22: v = UnownedStringSlice{"Triangles"}; return true; + case 23: v = UnownedStringSlice{"InputTrianglesAdjacency"}; return true; + case 24: v = UnownedStringSlice{"Quads"}; return true; + case 25: v = UnownedStringSlice{"Isolines"}; return true; + case 26: v = UnownedStringSlice{"OutputVertices"}; return true; + case 27: v = UnownedStringSlice{"OutputPoints"}; return true; + case 28: v = UnownedStringSlice{"OutputLineStrip"}; return true; + case 29: v = UnownedStringSlice{"OutputTriangleStrip"}; return true; + case 30: v = UnownedStringSlice{"VecTypeHint"}; return true; + case 31: v = UnownedStringSlice{"ContractionOff"}; return true; + case 33: v = UnownedStringSlice{"Initializer"}; return true; + case 34: v = UnownedStringSlice{"Finalizer"}; return true; + case 35: v = UnownedStringSlice{"SubgroupSize"}; return true; + case 36: v = UnownedStringSlice{"SubgroupsPerWorkgroup"}; return true; + case 37: v = UnownedStringSlice{"SubgroupsPerWorkgroupId"}; return true; + case 38: v = UnownedStringSlice{"LocalSizeId"}; return true; + case 39: v = UnownedStringSlice{"LocalSizeHintId"}; return true; + case 4169: v = UnownedStringSlice{"NonCoherentColorAttachmentReadEXT"}; return true; + case 4170: v = UnownedStringSlice{"NonCoherentDepthAttachmentReadEXT"}; return true; + case 4171: v = UnownedStringSlice{"NonCoherentStencilAttachmentReadEXT"}; return true; + case 4421: v = UnownedStringSlice{"SubgroupUniformControlFlowKHR"}; return true; + case 4446: v = UnownedStringSlice{"PostDepthCoverage"}; return true; + case 4459: v = UnownedStringSlice{"DenormPreserve"}; return true; + case 4460: v = UnownedStringSlice{"DenormFlushToZero"}; return true; + case 4461: v = UnownedStringSlice{"SignedZeroInfNanPreserve"}; return true; + case 4462: v = UnownedStringSlice{"RoundingModeRTE"}; return true; + case 4463: v = UnownedStringSlice{"RoundingModeRTZ"}; return true; + case 5017: v = UnownedStringSlice{"EarlyAndLateFragmentTestsAMD"}; return true; + case 5027: v = UnownedStringSlice{"StencilRefReplacingEXT"}; return true; + case 5079: v = UnownedStringSlice{"StencilRefUnchangedFrontAMD"}; return true; + case 5080: v = UnownedStringSlice{"StencilRefGreaterFrontAMD"}; return true; + case 5081: v = UnownedStringSlice{"StencilRefLessFrontAMD"}; return true; + case 5082: v = UnownedStringSlice{"StencilRefUnchangedBackAMD"}; return true; + case 5083: v = UnownedStringSlice{"StencilRefGreaterBackAMD"}; return true; + case 5084: v = UnownedStringSlice{"StencilRefLessBackAMD"}; return true; + case 5269: v = UnownedStringSlice{"OutputLinesNV"}; return true; + case 5270: v = UnownedStringSlice{"OutputPrimitivesNV"}; return true; + case 5289: v = UnownedStringSlice{"DerivativeGroupQuadsNV"}; return true; + case 5290: v = UnownedStringSlice{"DerivativeGroupLinearNV"}; return true; + case 5298: v = UnownedStringSlice{"OutputTrianglesNV"}; return true; + case 5366: v = UnownedStringSlice{"PixelInterlockOrderedEXT"}; return true; + case 5367: v = UnownedStringSlice{"PixelInterlockUnorderedEXT"}; return true; + case 5368: v = UnownedStringSlice{"SampleInterlockOrderedEXT"}; return true; + case 5369: v = UnownedStringSlice{"SampleInterlockUnorderedEXT"}; return true; + case 5370: v = UnownedStringSlice{"ShadingRateInterlockOrderedEXT"}; return true; + case 5371: v = UnownedStringSlice{"ShadingRateInterlockUnorderedEXT"}; return true; + case 5618: v = UnownedStringSlice{"SharedLocalMemorySizeINTEL"}; return true; + case 5620: v = UnownedStringSlice{"RoundingModeRTPINTEL"}; return true; + case 5621: v = UnownedStringSlice{"RoundingModeRTNINTEL"}; return true; + case 5622: v = UnownedStringSlice{"FloatingPointModeALTINTEL"}; return true; + case 5623: v = UnownedStringSlice{"FloatingPointModeIEEEINTEL"}; return true; + case 5893: v = UnownedStringSlice{"MaxWorkgroupSizeINTEL"}; return true; + case 5894: v = UnownedStringSlice{"MaxWorkDimINTEL"}; return true; + case 5895: v = UnownedStringSlice{"NoGlobalOffsetINTEL"}; return true; + case 5896: v = UnownedStringSlice{"NumSIMDWorkitemsINTEL"}; return true; + case 5903: v = UnownedStringSlice{"SchedulerTargetFmaxMhzINTEL"}; return true; + case 6154: v = UnownedStringSlice{"StreamingInterfaceINTEL"}; return true; + case 6160: v = UnownedStringSlice{"RegisterMapInterfaceINTEL"}; return true; + case 6417: v = UnownedStringSlice{"NamedBarrierCountINTEL"}; return true; + default: return false; + } + case 15: + switch(k2) + { + case 0: v = UnownedStringSlice{"UniformConstant"}; return true; + case 1: v = UnownedStringSlice{"Input"}; return true; + case 2: v = UnownedStringSlice{"Uniform"}; return true; + case 3: v = UnownedStringSlice{"Output"}; return true; + case 4: v = UnownedStringSlice{"Workgroup"}; return true; + case 5: v = UnownedStringSlice{"CrossWorkgroup"}; return true; + case 6: v = UnownedStringSlice{"Private"}; return true; + case 7: v = UnownedStringSlice{"Function"}; return true; + case 8: v = UnownedStringSlice{"Generic"}; return true; + case 9: v = UnownedStringSlice{"PushConstant"}; return true; + case 10: v = UnownedStringSlice{"AtomicCounter"}; return true; + case 11: v = UnownedStringSlice{"Image"}; return true; + case 12: v = UnownedStringSlice{"StorageBuffer"}; return true; + case 4172: v = UnownedStringSlice{"TileImageEXT"}; return true; + case 5328: v = UnownedStringSlice{"CallableDataNV"}; return true; + case 5329: v = UnownedStringSlice{"IncomingCallableDataNV"}; return true; + case 5338: v = UnownedStringSlice{"RayPayloadNV"}; return true; + case 5339: v = UnownedStringSlice{"HitAttributeNV"}; return true; + case 5342: v = UnownedStringSlice{"IncomingRayPayloadNV"}; return true; + case 5343: v = UnownedStringSlice{"ShaderRecordBufferNV"}; return true; + case 5349: v = UnownedStringSlice{"PhysicalStorageBuffer"}; return true; + case 5385: v = UnownedStringSlice{"HitObjectAttributeNV"}; return true; + case 5402: v = UnownedStringSlice{"TaskPayloadWorkgroupEXT"}; return true; + case 5605: v = UnownedStringSlice{"CodeSectionINTEL"}; return true; + case 5936: v = UnownedStringSlice{"DeviceOnlyINTEL"}; return true; + case 5937: v = UnownedStringSlice{"HostOnlyINTEL"}; return true; + default: return false; + } + case 16: + switch(k2) + { + case 0: v = UnownedStringSlice{"1D"}; return true; + case 1: v = UnownedStringSlice{"2D"}; return true; + case 2: v = UnownedStringSlice{"3D"}; return true; + case 3: v = UnownedStringSlice{"Cube"}; return true; + case 4: v = UnownedStringSlice{"Rect"}; return true; + case 5: v = UnownedStringSlice{"Buffer"}; return true; + case 6: v = UnownedStringSlice{"SubpassData"}; return true; + case 4173: v = UnownedStringSlice{"TileImageDataEXT"}; return true; + default: return false; + } + case 17: + switch(k2) + { + case 0: v = UnownedStringSlice{"None"}; return true; + case 1: v = UnownedStringSlice{"ClampToEdge"}; return true; + case 2: v = UnownedStringSlice{"Clamp"}; return true; + case 3: v = UnownedStringSlice{"Repeat"}; return true; + case 4: v = UnownedStringSlice{"RepeatMirrored"}; return true; + default: return false; + } + case 18: + switch(k2) + { + case 0: v = UnownedStringSlice{"Nearest"}; return true; + case 1: v = UnownedStringSlice{"Linear"}; return true; + default: return false; + } + case 19: + switch(k2) + { + case 0: v = UnownedStringSlice{"Unknown"}; return true; + case 1: v = UnownedStringSlice{"Rgba32f"}; return true; + case 2: v = UnownedStringSlice{"Rgba16f"}; return true; + case 3: v = UnownedStringSlice{"R32f"}; return true; + case 4: v = UnownedStringSlice{"Rgba8"}; return true; + case 5: v = UnownedStringSlice{"Rgba8Snorm"}; return true; + case 6: v = UnownedStringSlice{"Rg32f"}; return true; + case 7: v = UnownedStringSlice{"Rg16f"}; return true; + case 8: v = UnownedStringSlice{"R11fG11fB10f"}; return true; + case 9: v = UnownedStringSlice{"R16f"}; return true; + case 10: v = UnownedStringSlice{"Rgba16"}; return true; + case 11: v = UnownedStringSlice{"Rgb10A2"}; return true; + case 12: v = UnownedStringSlice{"Rg16"}; return true; + case 13: v = UnownedStringSlice{"Rg8"}; return true; + case 14: v = UnownedStringSlice{"R16"}; return true; + case 15: v = UnownedStringSlice{"R8"}; return true; + case 16: v = UnownedStringSlice{"Rgba16Snorm"}; return true; + case 17: v = UnownedStringSlice{"Rg16Snorm"}; return true; + case 18: v = UnownedStringSlice{"Rg8Snorm"}; return true; + case 19: v = UnownedStringSlice{"R16Snorm"}; return true; + case 20: v = UnownedStringSlice{"R8Snorm"}; return true; + case 21: v = UnownedStringSlice{"Rgba32i"}; return true; + case 22: v = UnownedStringSlice{"Rgba16i"}; return true; + case 23: v = UnownedStringSlice{"Rgba8i"}; return true; + case 24: v = UnownedStringSlice{"R32i"}; return true; + case 25: v = UnownedStringSlice{"Rg32i"}; return true; + case 26: v = UnownedStringSlice{"Rg16i"}; return true; + case 27: v = UnownedStringSlice{"Rg8i"}; return true; + case 28: v = UnownedStringSlice{"R16i"}; return true; + case 29: v = UnownedStringSlice{"R8i"}; return true; + case 30: v = UnownedStringSlice{"Rgba32ui"}; return true; + case 31: v = UnownedStringSlice{"Rgba16ui"}; return true; + case 32: v = UnownedStringSlice{"Rgba8ui"}; return true; + case 33: v = UnownedStringSlice{"R32ui"}; return true; + case 34: v = UnownedStringSlice{"Rgb10a2ui"}; return true; + case 35: v = UnownedStringSlice{"Rg32ui"}; return true; + case 36: v = UnownedStringSlice{"Rg16ui"}; return true; + case 37: v = UnownedStringSlice{"Rg8ui"}; return true; + case 38: v = UnownedStringSlice{"R16ui"}; return true; + case 39: v = UnownedStringSlice{"R8ui"}; return true; + case 40: v = UnownedStringSlice{"R64ui"}; return true; + case 41: v = UnownedStringSlice{"R64i"}; return true; + default: return false; + } + case 20: + switch(k2) + { + case 0: v = UnownedStringSlice{"R"}; return true; + case 1: v = UnownedStringSlice{"A"}; return true; + case 2: v = UnownedStringSlice{"RG"}; return true; + case 3: v = UnownedStringSlice{"RA"}; return true; + case 4: v = UnownedStringSlice{"RGB"}; return true; + case 5: v = UnownedStringSlice{"RGBA"}; return true; + case 6: v = UnownedStringSlice{"BGRA"}; return true; + case 7: v = UnownedStringSlice{"ARGB"}; return true; + case 8: v = UnownedStringSlice{"Intensity"}; return true; + case 9: v = UnownedStringSlice{"Luminance"}; return true; + case 10: v = UnownedStringSlice{"Rx"}; return true; + case 11: v = UnownedStringSlice{"RGx"}; return true; + case 12: v = UnownedStringSlice{"RGBx"}; return true; + case 13: v = UnownedStringSlice{"Depth"}; return true; + case 14: v = UnownedStringSlice{"DepthStencil"}; return true; + case 15: v = UnownedStringSlice{"sRGB"}; return true; + case 16: v = UnownedStringSlice{"sRGBx"}; return true; + case 17: v = UnownedStringSlice{"sRGBA"}; return true; + case 18: v = UnownedStringSlice{"sBGRA"}; return true; + case 19: v = UnownedStringSlice{"ABGR"}; return true; + default: return false; + } + case 21: + switch(k2) + { + case 0: v = UnownedStringSlice{"SnormInt8"}; return true; + case 1: v = UnownedStringSlice{"SnormInt16"}; return true; + case 2: v = UnownedStringSlice{"UnormInt8"}; return true; + case 3: v = UnownedStringSlice{"UnormInt16"}; return true; + case 4: v = UnownedStringSlice{"UnormShort565"}; return true; + case 5: v = UnownedStringSlice{"UnormShort555"}; return true; + case 6: v = UnownedStringSlice{"UnormInt101010"}; return true; + case 7: v = UnownedStringSlice{"SignedInt8"}; return true; + case 8: v = UnownedStringSlice{"SignedInt16"}; return true; + case 9: v = UnownedStringSlice{"SignedInt32"}; return true; + case 10: v = UnownedStringSlice{"UnsignedInt8"}; return true; + case 11: v = UnownedStringSlice{"UnsignedInt16"}; return true; + case 12: v = UnownedStringSlice{"UnsignedInt32"}; return true; + case 13: v = UnownedStringSlice{"HalfFloat"}; return true; + case 14: v = UnownedStringSlice{"Float"}; return true; + case 15: v = UnownedStringSlice{"UnormInt24"}; return true; + case 16: v = UnownedStringSlice{"UnormInt101010_2"}; return true; + case 19: v = UnownedStringSlice{"UnsignedIntRaw10EXT"}; return true; + case 20: v = UnownedStringSlice{"UnsignedIntRaw12EXT"}; return true; + default: return false; + } + case 22: + switch(k2) + { + case 0: v = UnownedStringSlice{"RTE"}; return true; + case 1: v = UnownedStringSlice{"RTZ"}; return true; + case 2: v = UnownedStringSlice{"RTP"}; return true; + case 3: v = UnownedStringSlice{"RTN"}; return true; + default: return false; + } + case 23: + switch(k2) + { + case 0: v = UnownedStringSlice{"Preserve"}; return true; + case 1: v = UnownedStringSlice{"FlushToZero"}; return true; + default: return false; + } + case 24: + switch(k2) + { + case 0: v = UnownedStringSlice{"TRN"}; return true; + case 1: v = UnownedStringSlice{"TRN_ZERO"}; return true; + case 2: v = UnownedStringSlice{"RND"}; return true; + case 3: v = UnownedStringSlice{"RND_ZERO"}; return true; + case 4: v = UnownedStringSlice{"RND_INF"}; return true; + case 5: v = UnownedStringSlice{"RND_MIN_INF"}; return true; + case 6: v = UnownedStringSlice{"RND_CONV"}; return true; + case 7: v = UnownedStringSlice{"RND_CONV_ODD"}; return true; + default: return false; + } + case 25: + switch(k2) + { + case 0: v = UnownedStringSlice{"IEEE"}; return true; + case 1: v = UnownedStringSlice{"ALT"}; return true; + default: return false; + } + case 26: + switch(k2) + { + case 0: v = UnownedStringSlice{"WRAP"}; return true; + case 1: v = UnownedStringSlice{"SAT"}; return true; + case 2: v = UnownedStringSlice{"SAT_ZERO"}; return true; + case 3: v = UnownedStringSlice{"SAT_SYM"}; return true; + default: return false; + } + case 27: + switch(k2) + { + case 0: v = UnownedStringSlice{"Export"}; return true; + case 1: v = UnownedStringSlice{"Import"}; return true; + case 2: v = UnownedStringSlice{"LinkOnceODR"}; return true; + default: return false; + } + case 28: + switch(k2) + { + case 0: v = UnownedStringSlice{"ReadOnly"}; return true; + case 1: v = UnownedStringSlice{"WriteOnly"}; return true; + case 2: v = UnownedStringSlice{"ReadWrite"}; return true; + default: return false; + } + case 29: + switch(k2) + { + case 0: v = UnownedStringSlice{"Zext"}; return true; + case 1: v = UnownedStringSlice{"Sext"}; return true; + case 2: v = UnownedStringSlice{"ByVal"}; return true; + case 3: v = UnownedStringSlice{"Sret"}; return true; + case 4: v = UnownedStringSlice{"NoAlias"}; return true; + case 5: v = UnownedStringSlice{"NoCapture"}; return true; + case 6: v = UnownedStringSlice{"NoWrite"}; return true; + case 7: v = UnownedStringSlice{"NoReadWrite"}; return true; + case 5940: v = UnownedStringSlice{"RuntimeAlignedINTEL"}; return true; + default: return false; + } + case 30: + switch(k2) + { + case 0: v = UnownedStringSlice{"RelaxedPrecision"}; return true; + case 1: v = UnownedStringSlice{"SpecId"}; return true; + case 2: v = UnownedStringSlice{"Block"}; return true; + case 3: v = UnownedStringSlice{"BufferBlock"}; return true; + case 4: v = UnownedStringSlice{"RowMajor"}; return true; + case 5: v = UnownedStringSlice{"ColMajor"}; return true; + case 6: v = UnownedStringSlice{"ArrayStride"}; return true; + case 7: v = UnownedStringSlice{"MatrixStride"}; return true; + case 8: v = UnownedStringSlice{"GLSLShared"}; return true; + case 9: v = UnownedStringSlice{"GLSLPacked"}; return true; + case 10: v = UnownedStringSlice{"CPacked"}; return true; + case 11: v = UnownedStringSlice{"BuiltIn"}; return true; + case 13: v = UnownedStringSlice{"NoPerspective"}; return true; + case 14: v = UnownedStringSlice{"Flat"}; return true; + case 15: v = UnownedStringSlice{"Patch"}; return true; + case 16: v = UnownedStringSlice{"Centroid"}; return true; + case 17: v = UnownedStringSlice{"Sample"}; return true; + case 18: v = UnownedStringSlice{"Invariant"}; return true; + case 19: v = UnownedStringSlice{"Restrict"}; return true; + case 20: v = UnownedStringSlice{"Aliased"}; return true; + case 21: v = UnownedStringSlice{"Volatile"}; return true; + case 22: v = UnownedStringSlice{"Constant"}; return true; + case 23: v = UnownedStringSlice{"Coherent"}; return true; + case 24: v = UnownedStringSlice{"NonWritable"}; return true; + case 25: v = UnownedStringSlice{"NonReadable"}; return true; + case 26: v = UnownedStringSlice{"Uniform"}; return true; + case 27: v = UnownedStringSlice{"UniformId"}; return true; + case 28: v = UnownedStringSlice{"SaturatedConversion"}; return true; + case 29: v = UnownedStringSlice{"Stream"}; return true; + case 30: v = UnownedStringSlice{"Location"}; return true; + case 31: v = UnownedStringSlice{"Component"}; return true; + case 32: v = UnownedStringSlice{"Index"}; return true; + case 33: v = UnownedStringSlice{"Binding"}; return true; + case 34: v = UnownedStringSlice{"DescriptorSet"}; return true; + case 35: v = UnownedStringSlice{"Offset"}; return true; + case 36: v = UnownedStringSlice{"XfbBuffer"}; return true; + case 37: v = UnownedStringSlice{"XfbStride"}; return true; + case 38: v = UnownedStringSlice{"FuncParamAttr"}; return true; + case 39: v = UnownedStringSlice{"FPRoundingMode"}; return true; + case 40: v = UnownedStringSlice{"FPFastMathMode"}; return true; + case 41: v = UnownedStringSlice{"LinkageAttributes"}; return true; + case 42: v = UnownedStringSlice{"NoContraction"}; return true; + case 43: v = UnownedStringSlice{"InputAttachmentIndex"}; return true; + case 44: v = UnownedStringSlice{"Alignment"}; return true; + case 45: v = UnownedStringSlice{"MaxByteOffset"}; return true; + case 46: v = UnownedStringSlice{"AlignmentId"}; return true; + case 47: v = UnownedStringSlice{"MaxByteOffsetId"}; return true; + case 4469: v = UnownedStringSlice{"NoSignedWrap"}; return true; + case 4470: v = UnownedStringSlice{"NoUnsignedWrap"}; return true; + case 4487: v = UnownedStringSlice{"WeightTextureQCOM"}; return true; + case 4488: v = UnownedStringSlice{"BlockMatchTextureQCOM"}; return true; + case 4999: v = UnownedStringSlice{"ExplicitInterpAMD"}; return true; + case 5248: v = UnownedStringSlice{"OverrideCoverageNV"}; return true; + case 5250: v = UnownedStringSlice{"PassthroughNV"}; return true; + case 5252: v = UnownedStringSlice{"ViewportRelativeNV"}; return true; + case 5256: v = UnownedStringSlice{"SecondaryViewportRelativeNV"}; return true; + case 5271: v = UnownedStringSlice{"PerPrimitiveNV"}; return true; + case 5272: v = UnownedStringSlice{"PerViewNV"}; return true; + case 5273: v = UnownedStringSlice{"PerTaskNV"}; return true; + case 5285: v = UnownedStringSlice{"PerVertexKHR"}; return true; + case 5300: v = UnownedStringSlice{"NonUniform"}; return true; + case 5355: v = UnownedStringSlice{"RestrictPointer"}; return true; + case 5356: v = UnownedStringSlice{"AliasedPointer"}; return true; + case 5386: v = UnownedStringSlice{"HitObjectShaderRecordBufferNV"}; return true; + case 5398: v = UnownedStringSlice{"BindlessSamplerNV"}; return true; + case 5399: v = UnownedStringSlice{"BindlessImageNV"}; return true; + case 5400: v = UnownedStringSlice{"BoundSamplerNV"}; return true; + case 5401: v = UnownedStringSlice{"BoundImageNV"}; return true; + case 5599: v = UnownedStringSlice{"SIMTCallINTEL"}; return true; + case 5602: v = UnownedStringSlice{"ReferencedIndirectlyINTEL"}; return true; + case 5607: v = UnownedStringSlice{"ClobberINTEL"}; return true; + case 5608: v = UnownedStringSlice{"SideEffectsINTEL"}; return true; + case 5624: v = UnownedStringSlice{"VectorComputeVariableINTEL"}; return true; + case 5625: v = UnownedStringSlice{"FuncParamIOKindINTEL"}; return true; + case 5626: v = UnownedStringSlice{"VectorComputeFunctionINTEL"}; return true; + case 5627: v = UnownedStringSlice{"StackCallINTEL"}; return true; + case 5628: v = UnownedStringSlice{"GlobalVariableOffsetINTEL"}; return true; + case 5634: v = UnownedStringSlice{"CounterBuffer"}; return true; + case 5635: v = UnownedStringSlice{"UserSemantic"}; return true; + case 5636: v = UnownedStringSlice{"UserTypeGOOGLE"}; return true; + case 5822: v = UnownedStringSlice{"FunctionRoundingModeINTEL"}; return true; + case 5823: v = UnownedStringSlice{"FunctionDenormModeINTEL"}; return true; + case 5825: v = UnownedStringSlice{"RegisterINTEL"}; return true; + case 5826: v = UnownedStringSlice{"MemoryINTEL"}; return true; + case 5827: v = UnownedStringSlice{"NumbanksINTEL"}; return true; + case 5828: v = UnownedStringSlice{"BankwidthINTEL"}; return true; + case 5829: v = UnownedStringSlice{"MaxPrivateCopiesINTEL"}; return true; + case 5830: v = UnownedStringSlice{"SinglepumpINTEL"}; return true; + case 5831: v = UnownedStringSlice{"DoublepumpINTEL"}; return true; + case 5832: v = UnownedStringSlice{"MaxReplicatesINTEL"}; return true; + case 5833: v = UnownedStringSlice{"SimpleDualPortINTEL"}; return true; + case 5834: v = UnownedStringSlice{"MergeINTEL"}; return true; + case 5835: v = UnownedStringSlice{"BankBitsINTEL"}; return true; + case 5836: v = UnownedStringSlice{"ForcePow2DepthINTEL"}; return true; + case 5899: v = UnownedStringSlice{"BurstCoalesceINTEL"}; return true; + case 5900: v = UnownedStringSlice{"CacheSizeINTEL"}; return true; + case 5901: v = UnownedStringSlice{"DontStaticallyCoalesceINTEL"}; return true; + case 5902: v = UnownedStringSlice{"PrefetchINTEL"}; return true; + case 5905: v = UnownedStringSlice{"StallEnableINTEL"}; return true; + case 5907: v = UnownedStringSlice{"FuseLoopsInFunctionINTEL"}; return true; + case 5909: v = UnownedStringSlice{"MathOpDSPModeINTEL"}; return true; + case 5914: v = UnownedStringSlice{"AliasScopeINTEL"}; return true; + case 5915: v = UnownedStringSlice{"NoAliasINTEL"}; return true; + case 5917: v = UnownedStringSlice{"InitiationIntervalINTEL"}; return true; + case 5918: v = UnownedStringSlice{"MaxConcurrencyINTEL"}; return true; + case 5919: v = UnownedStringSlice{"PipelineEnableINTEL"}; return true; + case 5921: v = UnownedStringSlice{"BufferLocationINTEL"}; return true; + case 5944: v = UnownedStringSlice{"IOPipeStorageINTEL"}; return true; + case 6080: v = UnownedStringSlice{"FunctionFloatingPointModeINTEL"}; return true; + case 6085: v = UnownedStringSlice{"SingleElementVectorINTEL"}; return true; + case 6087: v = UnownedStringSlice{"VectorComputeCallableFunctionINTEL"}; return true; + case 6140: v = UnownedStringSlice{"MediaBlockIOINTEL"}; return true; + case 6170: v = UnownedStringSlice{"FPMaxErrorDecorationINTEL"}; return true; + case 6172: v = UnownedStringSlice{"LatencyControlLabelINTEL"}; return true; + case 6173: v = UnownedStringSlice{"LatencyControlConstraintINTEL"}; return true; + case 6175: v = UnownedStringSlice{"ConduitKernelArgumentINTEL"}; return true; + case 6176: v = UnownedStringSlice{"RegisterMapKernelArgumentINTEL"}; return true; + case 6177: v = UnownedStringSlice{"MMHostInterfaceAddressWidthINTEL"}; return true; + case 6178: v = UnownedStringSlice{"MMHostInterfaceDataWidthINTEL"}; return true; + case 6179: v = UnownedStringSlice{"MMHostInterfaceLatencyINTEL"}; return true; + case 6180: v = UnownedStringSlice{"MMHostInterfaceReadWriteModeINTEL"}; return true; + case 6181: v = UnownedStringSlice{"MMHostInterfaceMaxBurstINTEL"}; return true; + case 6182: v = UnownedStringSlice{"MMHostInterfaceWaitRequestINTEL"}; return true; + case 6183: v = UnownedStringSlice{"StableKernelArgumentINTEL"}; return true; + default: return false; + } + case 31: + switch(k2) + { + case 0: v = UnownedStringSlice{"Position"}; return true; + case 1: v = UnownedStringSlice{"PointSize"}; return true; + case 3: v = UnownedStringSlice{"ClipDistance"}; return true; + case 4: v = UnownedStringSlice{"CullDistance"}; return true; + case 5: v = UnownedStringSlice{"VertexId"}; return true; + case 6: v = UnownedStringSlice{"InstanceId"}; return true; + case 7: v = UnownedStringSlice{"PrimitiveId"}; return true; + case 8: v = UnownedStringSlice{"InvocationId"}; return true; + case 9: v = UnownedStringSlice{"Layer"}; return true; + case 10: v = UnownedStringSlice{"ViewportIndex"}; return true; + case 11: v = UnownedStringSlice{"TessLevelOuter"}; return true; + case 12: v = UnownedStringSlice{"TessLevelInner"}; return true; + case 13: v = UnownedStringSlice{"TessCoord"}; return true; + case 14: v = UnownedStringSlice{"PatchVertices"}; return true; + case 15: v = UnownedStringSlice{"FragCoord"}; return true; + case 16: v = UnownedStringSlice{"PointCoord"}; return true; + case 17: v = UnownedStringSlice{"FrontFacing"}; return true; + case 18: v = UnownedStringSlice{"SampleId"}; return true; + case 19: v = UnownedStringSlice{"SamplePosition"}; return true; + case 20: v = UnownedStringSlice{"SampleMask"}; return true; + case 22: v = UnownedStringSlice{"FragDepth"}; return true; + case 23: v = UnownedStringSlice{"HelperInvocation"}; return true; + case 24: v = UnownedStringSlice{"NumWorkgroups"}; return true; + case 25: v = UnownedStringSlice{"WorkgroupSize"}; return true; + case 26: v = UnownedStringSlice{"WorkgroupId"}; return true; + case 27: v = UnownedStringSlice{"LocalInvocationId"}; return true; + case 28: v = UnownedStringSlice{"GlobalInvocationId"}; return true; + case 29: v = UnownedStringSlice{"LocalInvocationIndex"}; return true; + case 30: v = UnownedStringSlice{"WorkDim"}; return true; + case 31: v = UnownedStringSlice{"GlobalSize"}; return true; + case 32: v = UnownedStringSlice{"EnqueuedWorkgroupSize"}; return true; + case 33: v = UnownedStringSlice{"GlobalOffset"}; return true; + case 34: v = UnownedStringSlice{"GlobalLinearId"}; return true; + case 36: v = UnownedStringSlice{"SubgroupSize"}; return true; + case 37: v = UnownedStringSlice{"SubgroupMaxSize"}; return true; + case 38: v = UnownedStringSlice{"NumSubgroups"}; return true; + case 39: v = UnownedStringSlice{"NumEnqueuedSubgroups"}; return true; + case 40: v = UnownedStringSlice{"SubgroupId"}; return true; + case 41: v = UnownedStringSlice{"SubgroupLocalInvocationId"}; return true; + case 42: v = UnownedStringSlice{"VertexIndex"}; return true; + case 43: v = UnownedStringSlice{"InstanceIndex"}; return true; + case 4160: v = UnownedStringSlice{"CoreIDARM"}; return true; + case 4161: v = UnownedStringSlice{"CoreCountARM"}; return true; + case 4162: v = UnownedStringSlice{"CoreMaxIDARM"}; return true; + case 4163: v = UnownedStringSlice{"WarpIDARM"}; return true; + case 4164: v = UnownedStringSlice{"WarpMaxIDARM"}; return true; + case 4416: v = UnownedStringSlice{"SubgroupEqMask"}; return true; + case 4417: v = UnownedStringSlice{"SubgroupGeMask"}; return true; + case 4418: v = UnownedStringSlice{"SubgroupGtMask"}; return true; + case 4419: v = UnownedStringSlice{"SubgroupLeMask"}; return true; + case 4420: v = UnownedStringSlice{"SubgroupLtMask"}; return true; + case 4424: v = UnownedStringSlice{"BaseVertex"}; return true; + case 4425: v = UnownedStringSlice{"BaseInstance"}; return true; + case 4426: v = UnownedStringSlice{"DrawIndex"}; return true; + case 4432: v = UnownedStringSlice{"PrimitiveShadingRateKHR"}; return true; + case 4438: v = UnownedStringSlice{"DeviceIndex"}; return true; + case 4440: v = UnownedStringSlice{"ViewIndex"}; return true; + case 4444: v = UnownedStringSlice{"ShadingRateKHR"}; return true; + case 4992: v = UnownedStringSlice{"BaryCoordNoPerspAMD"}; return true; + case 4993: v = UnownedStringSlice{"BaryCoordNoPerspCentroidAMD"}; return true; + case 4994: v = UnownedStringSlice{"BaryCoordNoPerspSampleAMD"}; return true; + case 4995: v = UnownedStringSlice{"BaryCoordSmoothAMD"}; return true; + case 4996: v = UnownedStringSlice{"BaryCoordSmoothCentroidAMD"}; return true; + case 4997: v = UnownedStringSlice{"BaryCoordSmoothSampleAMD"}; return true; + case 4998: v = UnownedStringSlice{"BaryCoordPullModelAMD"}; return true; + case 5014: v = UnownedStringSlice{"FragStencilRefEXT"}; return true; + case 5253: v = UnownedStringSlice{"ViewportMaskNV"}; return true; + case 5257: v = UnownedStringSlice{"SecondaryPositionNV"}; return true; + case 5258: v = UnownedStringSlice{"SecondaryViewportMaskNV"}; return true; + case 5261: v = UnownedStringSlice{"PositionPerViewNV"}; return true; + case 5262: v = UnownedStringSlice{"ViewportMaskPerViewNV"}; return true; + case 5264: v = UnownedStringSlice{"FullyCoveredEXT"}; return true; + case 5274: v = UnownedStringSlice{"TaskCountNV"}; return true; + case 5275: v = UnownedStringSlice{"PrimitiveCountNV"}; return true; + case 5276: v = UnownedStringSlice{"PrimitiveIndicesNV"}; return true; + case 5277: v = UnownedStringSlice{"ClipDistancePerViewNV"}; return true; + case 5278: v = UnownedStringSlice{"CullDistancePerViewNV"}; return true; + case 5279: v = UnownedStringSlice{"LayerPerViewNV"}; return true; + case 5280: v = UnownedStringSlice{"MeshViewCountNV"}; return true; + case 5281: v = UnownedStringSlice{"MeshViewIndicesNV"}; return true; + case 5286: v = UnownedStringSlice{"BaryCoordKHR"}; return true; + case 5287: v = UnownedStringSlice{"BaryCoordNoPerspKHR"}; return true; + case 5292: v = UnownedStringSlice{"FragSizeEXT"}; return true; + case 5293: v = UnownedStringSlice{"FragInvocationCountEXT"}; return true; + case 5294: v = UnownedStringSlice{"PrimitivePointIndicesEXT"}; return true; + case 5295: v = UnownedStringSlice{"PrimitiveLineIndicesEXT"}; return true; + case 5296: v = UnownedStringSlice{"PrimitiveTriangleIndicesEXT"}; return true; + case 5299: v = UnownedStringSlice{"CullPrimitiveEXT"}; return true; + case 5319: v = UnownedStringSlice{"LaunchIdNV"}; return true; + case 5320: v = UnownedStringSlice{"LaunchSizeNV"}; return true; + case 5321: v = UnownedStringSlice{"WorldRayOriginNV"}; return true; + case 5322: v = UnownedStringSlice{"WorldRayDirectionNV"}; return true; + case 5323: v = UnownedStringSlice{"ObjectRayOriginNV"}; return true; + case 5324: v = UnownedStringSlice{"ObjectRayDirectionNV"}; return true; + case 5325: v = UnownedStringSlice{"RayTminNV"}; return true; + case 5326: v = UnownedStringSlice{"RayTmaxNV"}; return true; + case 5327: v = UnownedStringSlice{"InstanceCustomIndexNV"}; return true; + case 5330: v = UnownedStringSlice{"ObjectToWorldNV"}; return true; + case 5331: v = UnownedStringSlice{"WorldToObjectNV"}; return true; + case 5332: v = UnownedStringSlice{"HitTNV"}; return true; + case 5333: v = UnownedStringSlice{"HitKindNV"}; return true; + case 5334: v = UnownedStringSlice{"CurrentRayTimeNV"}; return true; + case 5335: v = UnownedStringSlice{"HitTriangleVertexPositionsKHR"}; return true; + case 5351: v = UnownedStringSlice{"IncomingRayFlagsNV"}; return true; + case 5352: v = UnownedStringSlice{"RayGeometryIndexKHR"}; return true; + case 5374: v = UnownedStringSlice{"WarpsPerSMNV"}; return true; + case 5375: v = UnownedStringSlice{"SMCountNV"}; return true; + case 5376: v = UnownedStringSlice{"WarpIDNV"}; return true; + case 5377: v = UnownedStringSlice{"SMIDNV"}; return true; + case 6021: v = UnownedStringSlice{"CullMaskKHR"}; return true; + default: return false; + } + case 32: + switch(k2) + { + case 0: v = UnownedStringSlice{"CrossDevice"}; return true; + case 1: v = UnownedStringSlice{"Device"}; return true; + case 2: v = UnownedStringSlice{"Workgroup"}; return true; + case 3: v = UnownedStringSlice{"Subgroup"}; return true; + case 4: v = UnownedStringSlice{"Invocation"}; return true; + case 5: v = UnownedStringSlice{"QueueFamily"}; return true; + case 6: v = UnownedStringSlice{"ShaderCallKHR"}; return true; + default: return false; + } + case 33: + switch(k2) + { + case 0: v = UnownedStringSlice{"Reduce"}; return true; + case 1: v = UnownedStringSlice{"InclusiveScan"}; return true; + case 2: v = UnownedStringSlice{"ExclusiveScan"}; return true; + case 3: v = UnownedStringSlice{"ClusteredReduce"}; return true; + case 6: v = UnownedStringSlice{"PartitionedReduceNV"}; return true; + case 7: v = UnownedStringSlice{"PartitionedInclusiveScanNV"}; return true; + case 8: v = UnownedStringSlice{"PartitionedExclusiveScanNV"}; return true; + default: return false; + } + case 34: + switch(k2) + { + case 0: v = UnownedStringSlice{"NoWait"}; return true; + case 1: v = UnownedStringSlice{"WaitKernel"}; return true; + case 2: v = UnownedStringSlice{"WaitWorkGroup"}; return true; + default: return false; + } + case 35: + switch(k2) + { + case 0: v = UnownedStringSlice{"Matrix"}; return true; + case 1: v = UnownedStringSlice{"Shader"}; return true; + case 2: v = UnownedStringSlice{"Geometry"}; return true; + case 3: v = UnownedStringSlice{"Tessellation"}; return true; + case 4: v = UnownedStringSlice{"Addresses"}; return true; + case 5: v = UnownedStringSlice{"Linkage"}; return true; + case 6: v = UnownedStringSlice{"Kernel"}; return true; + case 7: v = UnownedStringSlice{"Vector16"}; return true; + case 8: v = UnownedStringSlice{"Float16Buffer"}; return true; + case 9: v = UnownedStringSlice{"Float16"}; return true; + case 10: v = UnownedStringSlice{"Float64"}; return true; + case 11: v = UnownedStringSlice{"Int64"}; return true; + case 12: v = UnownedStringSlice{"Int64Atomics"}; return true; + case 13: v = UnownedStringSlice{"ImageBasic"}; return true; + case 14: v = UnownedStringSlice{"ImageReadWrite"}; return true; + case 15: v = UnownedStringSlice{"ImageMipmap"}; return true; + case 17: v = UnownedStringSlice{"Pipes"}; return true; + case 18: v = UnownedStringSlice{"Groups"}; return true; + case 19: v = UnownedStringSlice{"DeviceEnqueue"}; return true; + case 20: v = UnownedStringSlice{"LiteralSampler"}; return true; + case 21: v = UnownedStringSlice{"AtomicStorage"}; return true; + case 22: v = UnownedStringSlice{"Int16"}; return true; + case 23: v = UnownedStringSlice{"TessellationPointSize"}; return true; + case 24: v = UnownedStringSlice{"GeometryPointSize"}; return true; + case 25: v = UnownedStringSlice{"ImageGatherExtended"}; return true; + case 27: v = UnownedStringSlice{"StorageImageMultisample"}; return true; + case 28: v = UnownedStringSlice{"UniformBufferArrayDynamicIndexing"}; return true; + case 29: v = UnownedStringSlice{"SampledImageArrayDynamicIndexing"}; return true; + case 30: v = UnownedStringSlice{"StorageBufferArrayDynamicIndexing"}; return true; + case 31: v = UnownedStringSlice{"StorageImageArrayDynamicIndexing"}; return true; + case 32: v = UnownedStringSlice{"ClipDistance"}; return true; + case 33: v = UnownedStringSlice{"CullDistance"}; return true; + case 34: v = UnownedStringSlice{"ImageCubeArray"}; return true; + case 35: v = UnownedStringSlice{"SampleRateShading"}; return true; + case 36: v = UnownedStringSlice{"ImageRect"}; return true; + case 37: v = UnownedStringSlice{"SampledRect"}; return true; + case 38: v = UnownedStringSlice{"GenericPointer"}; return true; + case 39: v = UnownedStringSlice{"Int8"}; return true; + case 40: v = UnownedStringSlice{"InputAttachment"}; return true; + case 41: v = UnownedStringSlice{"SparseResidency"}; return true; + case 42: v = UnownedStringSlice{"MinLod"}; return true; + case 43: v = UnownedStringSlice{"Sampled1D"}; return true; + case 44: v = UnownedStringSlice{"Image1D"}; return true; + case 45: v = UnownedStringSlice{"SampledCubeArray"}; return true; + case 46: v = UnownedStringSlice{"SampledBuffer"}; return true; + case 47: v = UnownedStringSlice{"ImageBuffer"}; return true; + case 48: v = UnownedStringSlice{"ImageMSArray"}; return true; + case 49: v = UnownedStringSlice{"StorageImageExtendedFormats"}; return true; + case 50: v = UnownedStringSlice{"ImageQuery"}; return true; + case 51: v = UnownedStringSlice{"DerivativeControl"}; return true; + case 52: v = UnownedStringSlice{"InterpolationFunction"}; return true; + case 53: v = UnownedStringSlice{"TransformFeedback"}; return true; + case 54: v = UnownedStringSlice{"GeometryStreams"}; return true; + case 55: v = UnownedStringSlice{"StorageImageReadWithoutFormat"}; return true; + case 56: v = UnownedStringSlice{"StorageImageWriteWithoutFormat"}; return true; + case 57: v = UnownedStringSlice{"MultiViewport"}; return true; + case 58: v = UnownedStringSlice{"SubgroupDispatch"}; return true; + case 59: v = UnownedStringSlice{"NamedBarrier"}; return true; + case 60: v = UnownedStringSlice{"PipeStorage"}; return true; + case 61: v = UnownedStringSlice{"GroupNonUniform"}; return true; + case 62: v = UnownedStringSlice{"GroupNonUniformVote"}; return true; + case 63: v = UnownedStringSlice{"GroupNonUniformArithmetic"}; return true; + case 64: v = UnownedStringSlice{"GroupNonUniformBallot"}; return true; + case 65: v = UnownedStringSlice{"GroupNonUniformShuffle"}; return true; + case 66: v = UnownedStringSlice{"GroupNonUniformShuffleRelative"}; return true; + case 67: v = UnownedStringSlice{"GroupNonUniformClustered"}; return true; + case 68: v = UnownedStringSlice{"GroupNonUniformQuad"}; return true; + case 69: v = UnownedStringSlice{"ShaderLayer"}; return true; + case 70: v = UnownedStringSlice{"ShaderViewportIndex"}; return true; + case 71: v = UnownedStringSlice{"UniformDecoration"}; return true; + case 4165: v = UnownedStringSlice{"CoreBuiltinsARM"}; return true; + case 4166: v = UnownedStringSlice{"TileImageColorReadAccessEXT"}; return true; + case 4167: v = UnownedStringSlice{"TileImageDepthReadAccessEXT"}; return true; + case 4168: v = UnownedStringSlice{"TileImageStencilReadAccessEXT"}; return true; + case 4422: v = UnownedStringSlice{"FragmentShadingRateKHR"}; return true; + case 4423: v = UnownedStringSlice{"SubgroupBallotKHR"}; return true; + case 4427: v = UnownedStringSlice{"DrawParameters"}; return true; + case 4428: v = UnownedStringSlice{"WorkgroupMemoryExplicitLayoutKHR"}; return true; + case 4429: v = UnownedStringSlice{"WorkgroupMemoryExplicitLayout8BitAccessKHR"}; return true; + case 4430: v = UnownedStringSlice{"WorkgroupMemoryExplicitLayout16BitAccessKHR"}; return true; + case 4431: v = UnownedStringSlice{"SubgroupVoteKHR"}; return true; + case 4433: v = UnownedStringSlice{"StorageBuffer16BitAccess"}; return true; + case 4434: v = UnownedStringSlice{"UniformAndStorageBuffer16BitAccess"}; return true; + case 4435: v = UnownedStringSlice{"StoragePushConstant16"}; return true; + case 4436: v = UnownedStringSlice{"StorageInputOutput16"}; return true; + case 4437: v = UnownedStringSlice{"DeviceGroup"}; return true; + case 4439: v = UnownedStringSlice{"MultiView"}; return true; + case 4441: v = UnownedStringSlice{"VariablePointersStorageBuffer"}; return true; + case 4442: v = UnownedStringSlice{"VariablePointers"}; return true; + case 4445: v = UnownedStringSlice{"AtomicStorageOps"}; return true; + case 4447: v = UnownedStringSlice{"SampleMaskPostDepthCoverage"}; return true; + case 4448: v = UnownedStringSlice{"StorageBuffer8BitAccess"}; return true; + case 4449: v = UnownedStringSlice{"UniformAndStorageBuffer8BitAccess"}; return true; + case 4450: v = UnownedStringSlice{"StoragePushConstant8"}; return true; + case 4464: v = UnownedStringSlice{"DenormPreserve"}; return true; + case 4465: v = UnownedStringSlice{"DenormFlushToZero"}; return true; + case 4466: v = UnownedStringSlice{"SignedZeroInfNanPreserve"}; return true; + case 4467: v = UnownedStringSlice{"RoundingModeRTE"}; return true; + case 4468: v = UnownedStringSlice{"RoundingModeRTZ"}; return true; + case 4471: v = UnownedStringSlice{"RayQueryProvisionalKHR"}; return true; + case 4472: v = UnownedStringSlice{"RayQueryKHR"}; return true; + case 4478: v = UnownedStringSlice{"RayTraversalPrimitiveCullingKHR"}; return true; + case 4479: v = UnownedStringSlice{"RayTracingKHR"}; return true; + case 4484: v = UnownedStringSlice{"TextureSampleWeightedQCOM"}; return true; + case 4485: v = UnownedStringSlice{"TextureBoxFilterQCOM"}; return true; + case 4486: v = UnownedStringSlice{"TextureBlockMatchQCOM"}; return true; + case 5008: v = UnownedStringSlice{"Float16ImageAMD"}; return true; + case 5009: v = UnownedStringSlice{"ImageGatherBiasLodAMD"}; return true; + case 5010: v = UnownedStringSlice{"FragmentMaskAMD"}; return true; + case 5013: v = UnownedStringSlice{"StencilExportEXT"}; return true; + case 5015: v = UnownedStringSlice{"ImageReadWriteLodAMD"}; return true; + case 5016: v = UnownedStringSlice{"Int64ImageEXT"}; return true; + case 5055: v = UnownedStringSlice{"ShaderClockKHR"}; return true; + case 5249: v = UnownedStringSlice{"SampleMaskOverrideCoverageNV"}; return true; + case 5251: v = UnownedStringSlice{"GeometryShaderPassthroughNV"}; return true; + case 5254: v = UnownedStringSlice{"ShaderViewportIndexLayerEXT"}; return true; + case 5255: v = UnownedStringSlice{"ShaderViewportMaskNV"}; return true; + case 5259: v = UnownedStringSlice{"ShaderStereoViewNV"}; return true; + case 5260: v = UnownedStringSlice{"PerViewAttributesNV"}; return true; + case 5265: v = UnownedStringSlice{"FragmentFullyCoveredEXT"}; return true; + case 5266: v = UnownedStringSlice{"MeshShadingNV"}; return true; + case 5282: v = UnownedStringSlice{"ImageFootprintNV"}; return true; + case 5283: v = UnownedStringSlice{"MeshShadingEXT"}; return true; + case 5284: v = UnownedStringSlice{"FragmentBarycentricKHR"}; return true; + case 5288: v = UnownedStringSlice{"ComputeDerivativeGroupQuadsNV"}; return true; + case 5291: v = UnownedStringSlice{"FragmentDensityEXT"}; return true; + case 5297: v = UnownedStringSlice{"GroupNonUniformPartitionedNV"}; return true; + case 5301: v = UnownedStringSlice{"ShaderNonUniform"}; return true; + case 5302: v = UnownedStringSlice{"RuntimeDescriptorArray"}; return true; + case 5303: v = UnownedStringSlice{"InputAttachmentArrayDynamicIndexing"}; return true; + case 5304: v = UnownedStringSlice{"UniformTexelBufferArrayDynamicIndexing"}; return true; + case 5305: v = UnownedStringSlice{"StorageTexelBufferArrayDynamicIndexing"}; return true; + case 5306: v = UnownedStringSlice{"UniformBufferArrayNonUniformIndexing"}; return true; + case 5307: v = UnownedStringSlice{"SampledImageArrayNonUniformIndexing"}; return true; + case 5308: v = UnownedStringSlice{"StorageBufferArrayNonUniformIndexing"}; return true; + case 5309: v = UnownedStringSlice{"StorageImageArrayNonUniformIndexing"}; return true; + case 5310: v = UnownedStringSlice{"InputAttachmentArrayNonUniformIndexing"}; return true; + case 5311: v = UnownedStringSlice{"UniformTexelBufferArrayNonUniformIndexing"}; return true; + case 5312: v = UnownedStringSlice{"StorageTexelBufferArrayNonUniformIndexing"}; return true; + case 5336: v = UnownedStringSlice{"RayTracingPositionFetchKHR"}; return true; + case 5340: v = UnownedStringSlice{"RayTracingNV"}; return true; + case 5341: v = UnownedStringSlice{"RayTracingMotionBlurNV"}; return true; + case 5345: v = UnownedStringSlice{"VulkanMemoryModel"}; return true; + case 5346: v = UnownedStringSlice{"VulkanMemoryModelDeviceScope"}; return true; + case 5347: v = UnownedStringSlice{"PhysicalStorageBufferAddresses"}; return true; + case 5350: v = UnownedStringSlice{"ComputeDerivativeGroupLinearNV"}; return true; + case 5353: v = UnownedStringSlice{"RayTracingProvisionalKHR"}; return true; + case 5357: v = UnownedStringSlice{"CooperativeMatrixNV"}; return true; + case 5363: v = UnownedStringSlice{"FragmentShaderSampleInterlockEXT"}; return true; + case 5372: v = UnownedStringSlice{"FragmentShaderShadingRateInterlockEXT"}; return true; + case 5373: v = UnownedStringSlice{"ShaderSMBuiltinsNV"}; return true; + case 5378: v = UnownedStringSlice{"FragmentShaderPixelInterlockEXT"}; return true; + case 5379: v = UnownedStringSlice{"DemoteToHelperInvocation"}; return true; + case 5381: v = UnownedStringSlice{"RayTracingOpacityMicromapEXT"}; return true; + case 5383: v = UnownedStringSlice{"ShaderInvocationReorderNV"}; return true; + case 5390: v = UnownedStringSlice{"BindlessTextureNV"}; return true; + case 5391: v = UnownedStringSlice{"RayQueryPositionFetchKHR"}; return true; + case 5568: v = UnownedStringSlice{"SubgroupShuffleINTEL"}; return true; + case 5569: v = UnownedStringSlice{"SubgroupBufferBlockIOINTEL"}; return true; + case 5570: v = UnownedStringSlice{"SubgroupImageBlockIOINTEL"}; return true; + case 5579: v = UnownedStringSlice{"SubgroupImageMediaBlockIOINTEL"}; return true; + case 5582: v = UnownedStringSlice{"RoundToInfinityINTEL"}; return true; + case 5583: v = UnownedStringSlice{"FloatingPointModeINTEL"}; return true; + case 5584: v = UnownedStringSlice{"IntegerFunctions2INTEL"}; return true; + case 5603: v = UnownedStringSlice{"FunctionPointersINTEL"}; return true; + case 5604: v = UnownedStringSlice{"IndirectReferencesINTEL"}; return true; + case 5606: v = UnownedStringSlice{"AsmINTEL"}; return true; + case 5612: v = UnownedStringSlice{"AtomicFloat32MinMaxEXT"}; return true; + case 5613: v = UnownedStringSlice{"AtomicFloat64MinMaxEXT"}; return true; + case 5616: v = UnownedStringSlice{"AtomicFloat16MinMaxEXT"}; return true; + case 5617: v = UnownedStringSlice{"VectorComputeINTEL"}; return true; + case 5619: v = UnownedStringSlice{"VectorAnyINTEL"}; return true; + case 5629: v = UnownedStringSlice{"ExpectAssumeKHR"}; return true; + case 5696: v = UnownedStringSlice{"SubgroupAvcMotionEstimationINTEL"}; return true; + case 5697: v = UnownedStringSlice{"SubgroupAvcMotionEstimationIntraINTEL"}; return true; + case 5698: v = UnownedStringSlice{"SubgroupAvcMotionEstimationChromaINTEL"}; return true; + case 5817: v = UnownedStringSlice{"VariableLengthArrayINTEL"}; return true; + case 5821: v = UnownedStringSlice{"FunctionFloatControlINTEL"}; return true; + case 5824: v = UnownedStringSlice{"FPGAMemoryAttributesINTEL"}; return true; + case 5837: v = UnownedStringSlice{"FPFastMathModeINTEL"}; return true; + case 5844: v = UnownedStringSlice{"ArbitraryPrecisionIntegersINTEL"}; return true; + case 5845: v = UnownedStringSlice{"ArbitraryPrecisionFloatingPointINTEL"}; return true; + case 5886: v = UnownedStringSlice{"UnstructuredLoopControlsINTEL"}; return true; + case 5888: v = UnownedStringSlice{"FPGALoopControlsINTEL"}; return true; + case 5892: v = UnownedStringSlice{"KernelAttributesINTEL"}; return true; + case 5897: v = UnownedStringSlice{"FPGAKernelAttributesINTEL"}; return true; + case 5898: v = UnownedStringSlice{"FPGAMemoryAccessesINTEL"}; return true; + case 5904: v = UnownedStringSlice{"FPGAClusterAttributesINTEL"}; return true; + case 5906: v = UnownedStringSlice{"LoopFuseINTEL"}; return true; + case 5908: v = UnownedStringSlice{"FPGADSPControlINTEL"}; return true; + case 5910: v = UnownedStringSlice{"MemoryAccessAliasingINTEL"}; return true; + case 5916: v = UnownedStringSlice{"FPGAInvocationPipeliningAttributesINTEL"}; return true; + case 5920: v = UnownedStringSlice{"FPGABufferLocationINTEL"}; return true; + case 5922: v = UnownedStringSlice{"ArbitraryPrecisionFixedPointINTEL"}; return true; + case 5935: v = UnownedStringSlice{"USMStorageClassesINTEL"}; return true; + case 5939: v = UnownedStringSlice{"RuntimeAlignedAttributeINTEL"}; return true; + case 5943: v = UnownedStringSlice{"IOPipesINTEL"}; return true; + case 5945: v = UnownedStringSlice{"BlockingPipesINTEL"}; return true; + case 5948: v = UnownedStringSlice{"FPGARegINTEL"}; return true; + case 6016: v = UnownedStringSlice{"DotProductInputAll"}; return true; + case 6017: v = UnownedStringSlice{"DotProductInput4x8Bit"}; return true; + case 6018: v = UnownedStringSlice{"DotProductInput4x8BitPacked"}; return true; + case 6019: v = UnownedStringSlice{"DotProduct"}; return true; + case 6020: v = UnownedStringSlice{"RayCullMaskKHR"}; return true; + case 6022: v = UnownedStringSlice{"CooperativeMatrixKHR"}; return true; + case 6025: v = UnownedStringSlice{"BitInstructions"}; return true; + case 6026: v = UnownedStringSlice{"GroupNonUniformRotateKHR"}; return true; + case 6033: v = UnownedStringSlice{"AtomicFloat32AddEXT"}; return true; + case 6034: v = UnownedStringSlice{"AtomicFloat64AddEXT"}; return true; + case 6089: v = UnownedStringSlice{"LongConstantCompositeINTEL"}; return true; + case 6094: v = UnownedStringSlice{"OptNoneINTEL"}; return true; + case 6095: v = UnownedStringSlice{"AtomicFloat16AddEXT"}; return true; + case 6114: v = UnownedStringSlice{"DebugInfoModuleINTEL"}; return true; + case 6115: v = UnownedStringSlice{"BFloat16ConversionINTEL"}; return true; + case 6141: v = UnownedStringSlice{"SplitBarrierINTEL"}; return true; + case 6161: v = UnownedStringSlice{"FPGAKernelAttributesv2INTEL"}; return true; + case 6169: v = UnownedStringSlice{"FPMaxErrorINTEL"}; return true; + case 6171: v = UnownedStringSlice{"FPGALatencyControlINTEL"}; return true; + case 6174: v = UnownedStringSlice{"FPGAArgumentInterfacesINTEL"}; return true; + case 6400: v = UnownedStringSlice{"GroupUniformArithmeticKHR"}; return true; + default: return false; + } + case 36: + switch(k2) + { + case 0: v = UnownedStringSlice{"RayQueryCandidateIntersectionKHR"}; return true; + case 1: v = UnownedStringSlice{"RayQueryCommittedIntersectionKHR"}; return true; + default: return false; + } + case 37: + switch(k2) + { + case 0: v = UnownedStringSlice{"RayQueryCommittedIntersectionNoneKHR"}; return true; + case 1: v = UnownedStringSlice{"RayQueryCommittedIntersectionTriangleKHR"}; return true; + case 2: v = UnownedStringSlice{"RayQueryCommittedIntersectionGeneratedKHR"}; return true; + default: return false; + } + case 38: + switch(k2) + { + case 0: v = UnownedStringSlice{"RayQueryCandidateIntersectionTriangleKHR"}; return true; + case 1: v = UnownedStringSlice{"RayQueryCandidateIntersectionAABBKHR"}; return true; + default: return false; + } + case 39: + switch(k2) + { + case 0: v = UnownedStringSlice{"PackedVectorFormat4x8Bit"}; return true; + default: return false; + } + case 40: + switch(k2) + { + case 0: v = UnownedStringSlice{"NoneKHR"}; return true; + case 1: v = UnownedStringSlice{"MatrixASignedComponentsKHR"}; return true; + case 2: v = UnownedStringSlice{"MatrixBSignedComponentsKHR"}; return true; + case 4: v = UnownedStringSlice{"MatrixCSignedComponentsKHR"}; return true; + case 8: v = UnownedStringSlice{"MatrixResultSignedComponentsKHR"}; return true; + case 16: v = UnownedStringSlice{"SaturatingAccumulationKHR"}; return true; + default: return false; + } + case 41: + switch(k2) + { + case 0: v = UnownedStringSlice{"RowMajorKHR"}; return true; + case 1: v = UnownedStringSlice{"ColumnMajorKHR"}; return true; + default: return false; + } + case 42: + switch(k2) + { + case 0: v = UnownedStringSlice{"MatrixAKHR"}; return true; + case 1: v = UnownedStringSlice{"MatrixBKHR"}; return true; + case 2: v = UnownedStringSlice{"MatrixAccumulatorKHR"}; return true; + default: return false; + } + default: return false; + } +} + +static bool getOperandKindName(const OperandKind& k, UnownedStringSlice& v) +{ + switch(k.index) + { + case 0: + { + v = UnownedStringSlice{"ImageOperands"}; + return true; + } + case 1: + { + v = UnownedStringSlice{"FPFastMathMode"}; + return true; + } + case 2: + { + v = UnownedStringSlice{"SelectionControl"}; + return true; + } + case 3: + { + v = UnownedStringSlice{"LoopControl"}; + return true; + } + case 4: + { + v = UnownedStringSlice{"FunctionControl"}; + return true; + } + case 5: + { + v = UnownedStringSlice{"MemorySemantics"}; + return true; + } + case 6: + { + v = UnownedStringSlice{"MemoryAccess"}; + return true; + } + case 7: + { + v = UnownedStringSlice{"KernelProfilingInfo"}; + return true; + } + case 8: + { + v = UnownedStringSlice{"RayFlags"}; + return true; + } + case 9: + { + v = UnownedStringSlice{"FragmentShadingRate"}; + return true; + } + case 10: + { + v = UnownedStringSlice{"SourceLanguage"}; + return true; + } + case 11: + { + v = UnownedStringSlice{"ExecutionModel"}; + return true; + } + case 12: + { + v = UnownedStringSlice{"AddressingModel"}; + return true; + } + case 13: + { + v = UnownedStringSlice{"MemoryModel"}; + return true; + } + case 14: + { + v = UnownedStringSlice{"ExecutionMode"}; + return true; + } + case 15: + { + v = UnownedStringSlice{"StorageClass"}; + return true; + } + case 16: + { + v = UnownedStringSlice{"Dim"}; + return true; + } + case 17: + { + v = UnownedStringSlice{"SamplerAddressingMode"}; + return true; + } + case 18: + { + v = UnownedStringSlice{"SamplerFilterMode"}; + return true; + } + case 19: + { + v = UnownedStringSlice{"ImageFormat"}; + return true; + } + case 20: + { + v = UnownedStringSlice{"ImageChannelOrder"}; + return true; + } + case 21: + { + v = UnownedStringSlice{"ImageChannelDataType"}; + return true; + } + case 22: + { + v = UnownedStringSlice{"FPRoundingMode"}; + return true; + } + case 23: + { + v = UnownedStringSlice{"FPDenormMode"}; + return true; + } + case 24: + { + v = UnownedStringSlice{"QuantizationModes"}; + return true; + } + case 25: + { + v = UnownedStringSlice{"FPOperationMode"}; + return true; + } + case 26: + { + v = UnownedStringSlice{"OverflowModes"}; + return true; + } + case 27: + { + v = UnownedStringSlice{"LinkageType"}; + return true; + } + case 28: + { + v = UnownedStringSlice{"AccessQualifier"}; + return true; + } + case 29: + { + v = UnownedStringSlice{"FunctionParameterAttribute"}; + return true; + } + case 30: + { + v = UnownedStringSlice{"Decoration"}; + return true; + } + case 31: + { + v = UnownedStringSlice{"BuiltIn"}; + return true; + } + case 32: + { + v = UnownedStringSlice{"Scope"}; + return true; + } + case 33: + { + v = UnownedStringSlice{"GroupOperation"}; + return true; + } + case 34: + { + v = UnownedStringSlice{"KernelEnqueueFlags"}; + return true; + } + case 35: + { + v = UnownedStringSlice{"Capability"}; + return true; + } + case 36: + { + v = UnownedStringSlice{"RayQueryIntersection"}; + return true; + } + case 37: + { + v = UnownedStringSlice{"RayQueryCommittedIntersectionType"}; + return true; + } + case 38: + { + v = UnownedStringSlice{"RayQueryCandidateIntersectionType"}; + return true; + } + case 39: + { + v = UnownedStringSlice{"PackedVectorFormat"}; + return true; + } + case 40: + { + v = UnownedStringSlice{"CooperativeMatrixOperands"}; + return true; + } + case 41: + { + v = UnownedStringSlice{"CooperativeMatrixLayout"}; + return true; + } + case 42: + { + v = UnownedStringSlice{"CooperativeMatrixUse"}; + return true; + } + case 43: + { + v = UnownedStringSlice{"IdResultType"}; + return true; + } + case 44: + { + v = UnownedStringSlice{"IdResult"}; + return true; + } + case 45: + { + v = UnownedStringSlice{"IdMemorySemantics"}; + return true; + } + case 46: + { + v = UnownedStringSlice{"IdScope"}; + return true; + } + case 47: + { + v = UnownedStringSlice{"IdRef"}; + return true; + } + case 48: + { + v = UnownedStringSlice{"LiteralInteger"}; + return true; + } + case 49: + { + v = UnownedStringSlice{"LiteralString"}; + return true; + } + case 50: + { + v = UnownedStringSlice{"LiteralContextDependentNumber"}; + return true; + } + case 51: + { + v = UnownedStringSlice{"LiteralExtInstInteger"}; + return true; + } + case 52: + { + v = UnownedStringSlice{"LiteralSpecConstantOpInteger"}; + return true; + } + case 53: + { + v = UnownedStringSlice{"PairLiteralIntegerIdRef"}; + return true; + } + case 54: + { + v = UnownedStringSlice{"PairIdRefLiteralInteger"}; + return true; + } + case 55: + { + v = UnownedStringSlice{"PairIdRefIdRef"}; + return true; + } + default: return false; + } +} + +static bool getOperandKindUnderneathId(const OperandKind& k, OperandKind& v) +{ + switch(k.index) + { + case 45: + { + v = OperandKind{5}; + return true; + } + case 46: + { + v = OperandKind{32}; + return true; + } + default: return false; + } +} + +RefPtr<SPIRVCoreGrammarInfo> SPIRVCoreGrammarInfo::getEmbeddedVersion() +{ + static SPIRVCoreGrammarInfo embedded = [](){ + SPIRVCoreGrammarInfo info; + info.opcodes.embedded = &lookupSpvOp; + info.capabilities.embedded = &lookupSpvCapability; + info.allEnumsWithTypePrefix.embedded = &lookupEnumWithTypePrefix; + info.opInfos.embedded = &getOpInfo; + info.opNames.embedded = &getOpName; + info.operandKinds.embedded = &lookupOperandKind; + info.allEnums.embedded = &lookupQualifiedEnum; + info.allEnumNames.embedded = &getQualifiedEnumName; + info.operandKindNames.embedded = &getOperandKindName; + info.operandKindUnderneathIds.embedded = &getOperandKindUnderneathId; + info.addReference(); + return info; + }(); + return &embedded; +} +} diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index da818984b..ae008cebb 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -220,6 +220,9 @@ void Session::init() m_languagePreludes[Index(SourceLanguage::CUDA)] = get_slang_cuda_prelude(); m_languagePreludes[Index(SourceLanguage::CPP)] = get_slang_cpp_prelude(); m_languagePreludes[Index(SourceLanguage::HLSL)] = get_slang_hlsl_prelude(); + + if(!spirvCoreGrammarInfo) + spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::getEmbeddedVersion(); } void Session::_initCodeGenTransitionMap() @@ -805,6 +808,34 @@ IDownstreamCompiler* Session::getDownstreamCompiler(CodeGenTarget source, CodeGe return getOrLoadDownstreamCompiler(compilerType, nullptr); } +SLANG_NO_THROW SlangResult SLANG_MCALL Session::setSPIRVCoreGrammar(char const* jsonPath) +{ + if(!jsonPath) + { + spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::getEmbeddedVersion(); + SLANG_ASSERT(spirvCoreGrammarInfo); + } + else + { + SourceManager* sourceManager = getBuiltinSourceManager(); + SLANG_ASSERT(sourceManager); + DiagnosticSink sink(sourceManager, Lexer::sourceLocationLexer); + + String contents; + const auto readRes = File::readAllText(jsonPath, contents); + if(SLANG_FAILED(readRes)) + { + sink.diagnose(SourceLoc{}, Diagnostics::unableToReadFile, jsonPath); + return readRes; + } + const auto pathInfo = PathInfo::makeFromString(jsonPath); + const auto sourceFile = sourceManager->createSourceFileWithString(pathInfo, contents); + const auto sourceView = sourceManager->createSourceView(sourceFile, nullptr, SourceLoc()); + spirvCoreGrammarInfo = SPIRVCoreGrammarInfo::loadFromJSON(*sourceView, sink); + } + return spirvCoreGrammarInfo ? SLANG_OK : SLANG_FAIL; +} + Profile getEffectiveProfile(EntryPoint* entryPoint, TargetRequest* target) { auto entryPointProfile = entryPoint->getProfile(); |