| // GENERATED FILE - DO NOT EDIT. |
| // Generated by gen_spirv_builder_and_parser.py using data from spirv.core.grammar.json. |
| // |
| // Copyright 2021 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // spirv_instruction_parser_autogen.cpp: |
| // Functions to parse SPIR-V binary for each instruction. |
| |
| #include "spirv_instruction_parser_autogen.h" |
| |
| #include <string.h> |
| |
| #include "common/debug.h" |
| |
| namespace angle |
| { |
| namespace spirv |
| { |
| |
| void GetInstructionOpAndLength(const uint32_t *_instruction, spv::Op *opOut, uint32_t *lengthOut) |
| { |
| constexpr uint32_t kOpMask = 0xFFFFu; |
| *opOut = static_cast<spv::Op>(_instruction[0] & kOpMask); |
| *lengthOut = _instruction[0] >> 16; |
| } |
| void ParseUndef(const uint32_t *_instruction, IdResultType *idResultType1, IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUndef); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseSourceContinued(const uint32_t *_instruction, LiteralString *continuedSource) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSourceContinued); |
| uint32_t _o = 1; |
| ASSERT(IsLittleEndian()); |
| *continuedSource = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*continuedSource) / 4 + 1; |
| } |
| void ParseSource(const uint32_t *_instruction, |
| spv::SourceLanguage *sourceLanguage1, |
| LiteralInteger *version, |
| IdRef *file, |
| LiteralString *source) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSource); |
| uint32_t _o = 1; |
| *sourceLanguage1 = spv::SourceLanguage(_instruction[_o++]); |
| *version = LiteralInteger(_instruction[_o++]); |
| if (file && _o < _length) |
| { |
| *file = IdRef(_instruction[_o++]); |
| } |
| if (source && _o < _length) |
| { |
| ASSERT(IsLittleEndian()); |
| *source = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*source) / 4 + 1; |
| } |
| } |
| void ParseSourceExtension(const uint32_t *_instruction, LiteralString *extension) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSourceExtension); |
| uint32_t _o = 1; |
| ASSERT(IsLittleEndian()); |
| *extension = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*extension) / 4 + 1; |
| } |
| void ParseName(const uint32_t *_instruction, IdRef *target, LiteralString *name) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpName); |
| uint32_t _o = 1; |
| *target = IdRef(_instruction[_o++]); |
| ASSERT(IsLittleEndian()); |
| *name = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*name) / 4 + 1; |
| } |
| void ParseMemberName(const uint32_t *_instruction, |
| IdRef *type, |
| LiteralInteger *member, |
| LiteralString *name) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMemberName); |
| uint32_t _o = 1; |
| *type = IdRef(_instruction[_o++]); |
| *member = LiteralInteger(_instruction[_o++]); |
| ASSERT(IsLittleEndian()); |
| *name = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*name) / 4 + 1; |
| } |
| void ParseString(const uint32_t *_instruction, IdResult *idResult1, LiteralString *string) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpString); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| ASSERT(IsLittleEndian()); |
| *string = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*string) / 4 + 1; |
| } |
| void ParseLine(const uint32_t *_instruction, |
| IdRef *file, |
| LiteralInteger *line, |
| LiteralInteger *column) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLine); |
| uint32_t _o = 1; |
| *file = IdRef(_instruction[_o++]); |
| *line = LiteralInteger(_instruction[_o++]); |
| *column = LiteralInteger(_instruction[_o++]); |
| } |
| void ParseExtension(const uint32_t *_instruction, LiteralString *name) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpExtension); |
| uint32_t _o = 1; |
| ASSERT(IsLittleEndian()); |
| *name = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*name) / 4 + 1; |
| } |
| void ParseExtInstImport(const uint32_t *_instruction, IdResult *idResult1, LiteralString *name) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpExtInstImport); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| ASSERT(IsLittleEndian()); |
| *name = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*name) / 4 + 1; |
| } |
| void ParseExtInst(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *set, |
| LiteralExtInstInteger *instruction, |
| IdRefList *operandList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpExtInst); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *set = IdRef(_instruction[_o++]); |
| *instruction = LiteralExtInstInteger(_instruction[_o++]); |
| if (operandList) |
| { |
| while (_o < _length) |
| { |
| operandList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseMemoryModel(const uint32_t *_instruction, |
| spv::AddressingModel *addressingModel1, |
| spv::MemoryModel *memoryModel2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMemoryModel); |
| uint32_t _o = 1; |
| *addressingModel1 = spv::AddressingModel(_instruction[_o++]); |
| *memoryModel2 = spv::MemoryModel(_instruction[_o++]); |
| } |
| void ParseEntryPoint(const uint32_t *_instruction, |
| spv::ExecutionModel *executionModel1, |
| IdRef *entryPoint, |
| LiteralString *name, |
| IdRefList *interfaceList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpEntryPoint); |
| uint32_t _o = 1; |
| *executionModel1 = spv::ExecutionModel(_instruction[_o++]); |
| *entryPoint = IdRef(_instruction[_o++]); |
| ASSERT(IsLittleEndian()); |
| *name = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*name) / 4 + 1; |
| if (interfaceList) |
| { |
| while (_o < _length) |
| { |
| interfaceList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseExecutionMode(const uint32_t *_instruction, |
| IdRef *entryPoint, |
| spv::ExecutionMode *mode, |
| LiteralIntegerList *operandsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpExecutionMode); |
| uint32_t _o = 1; |
| *entryPoint = IdRef(_instruction[_o++]); |
| *mode = spv::ExecutionMode(_instruction[_o++]); |
| if (operandsList) |
| { |
| while (_o < _length) |
| { |
| operandsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseCapability(const uint32_t *_instruction, spv::Capability *capability) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCapability); |
| uint32_t _o = 1; |
| *capability = spv::Capability(_instruction[_o++]); |
| } |
| void ParseTypeVoid(const uint32_t *_instruction, IdResult *idResult1) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeVoid); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| } |
| void ParseTypeBool(const uint32_t *_instruction, IdResult *idResult1) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeBool); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| } |
| void ParseTypeInt(const uint32_t *_instruction, |
| IdResult *idResult1, |
| LiteralInteger *width, |
| LiteralInteger *signedness) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeInt); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *width = LiteralInteger(_instruction[_o++]); |
| *signedness = LiteralInteger(_instruction[_o++]); |
| } |
| void ParseTypeFloat(const uint32_t *_instruction, |
| IdResult *idResult1, |
| LiteralInteger *width, |
| spv::FPEncoding *floatingPointEncoding) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeFloat); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *width = LiteralInteger(_instruction[_o++]); |
| if (floatingPointEncoding && _o < _length) |
| { |
| *floatingPointEncoding = spv::FPEncoding(_instruction[_o++]); |
| } |
| } |
| void ParseTypeVector(const uint32_t *_instruction, |
| IdResult *idResult1, |
| IdRef *componentType, |
| LiteralInteger *componentCount) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeVector); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *componentType = IdRef(_instruction[_o++]); |
| *componentCount = LiteralInteger(_instruction[_o++]); |
| } |
| void ParseTypeMatrix(const uint32_t *_instruction, |
| IdResult *idResult1, |
| IdRef *columnType, |
| LiteralInteger *columnCount) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeMatrix); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *columnType = IdRef(_instruction[_o++]); |
| *columnCount = LiteralInteger(_instruction[_o++]); |
| } |
| void ParseTypeImage(const uint32_t *_instruction, |
| IdResult *idResult1, |
| IdRef *sampledType, |
| spv::Dim *dim3, |
| LiteralInteger *depth, |
| LiteralInteger *arrayed, |
| LiteralInteger *mS, |
| LiteralInteger *sampled, |
| spv::ImageFormat *imageFormat8, |
| spv::AccessQualifier *accessQualifier9) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeImage); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *sampledType = IdRef(_instruction[_o++]); |
| *dim3 = spv::Dim(_instruction[_o++]); |
| *depth = LiteralInteger(_instruction[_o++]); |
| *arrayed = LiteralInteger(_instruction[_o++]); |
| *mS = LiteralInteger(_instruction[_o++]); |
| *sampled = LiteralInteger(_instruction[_o++]); |
| *imageFormat8 = spv::ImageFormat(_instruction[_o++]); |
| if (accessQualifier9 && _o < _length) |
| { |
| *accessQualifier9 = spv::AccessQualifier(_instruction[_o++]); |
| } |
| } |
| void ParseTypeSampler(const uint32_t *_instruction, IdResult *idResult1) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeSampler); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| } |
| void ParseTypeSampledImage(const uint32_t *_instruction, IdResult *idResult1, IdRef *imageType) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeSampledImage); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *imageType = IdRef(_instruction[_o++]); |
| } |
| void ParseTypeArray(const uint32_t *_instruction, |
| IdResult *idResult1, |
| IdRef *elementType, |
| IdRef *length) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeArray); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *elementType = IdRef(_instruction[_o++]); |
| *length = IdRef(_instruction[_o++]); |
| } |
| void ParseTypeRuntimeArray(const uint32_t *_instruction, IdResult *idResult1, IdRef *elementType) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeRuntimeArray); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *elementType = IdRef(_instruction[_o++]); |
| } |
| void ParseTypeStruct(const uint32_t *_instruction, IdResult *idResult1, IdRefList *memberList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeStruct); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| if (memberList) |
| { |
| while (_o < _length) |
| { |
| memberList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseTypePointer(const uint32_t *_instruction, |
| IdResult *idResult1, |
| spv::StorageClass *storageClass2, |
| IdRef *type) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypePointer); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *storageClass2 = spv::StorageClass(_instruction[_o++]); |
| *type = IdRef(_instruction[_o++]); |
| } |
| void ParseTypeFunction(const uint32_t *_instruction, |
| IdResult *idResult1, |
| IdRef *returnType, |
| IdRefList *parameterList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTypeFunction); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| *returnType = IdRef(_instruction[_o++]); |
| if (parameterList) |
| { |
| while (_o < _length) |
| { |
| parameterList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseConstantTrue(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConstantTrue); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseConstantFalse(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConstantFalse); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseConstant(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| LiteralContextDependentNumber *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConstant); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *value = LiteralContextDependentNumber(_instruction[_o++]); |
| } |
| void ParseConstantComposite(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRefList *constituentsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConstantComposite); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| if (constituentsList) |
| { |
| while (_o < _length) |
| { |
| constituentsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseConstantNull(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConstantNull); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseSpecConstantTrue(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSpecConstantTrue); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseSpecConstantFalse(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSpecConstantFalse); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseSpecConstant(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| LiteralContextDependentNumber *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSpecConstant); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *value = LiteralContextDependentNumber(_instruction[_o++]); |
| } |
| void ParseSpecConstantComposite(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRefList *constituentsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSpecConstantComposite); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| if (constituentsList) |
| { |
| while (_o < _length) |
| { |
| constituentsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseFunction(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| spv::FunctionControlMask *functionControl3, |
| IdRef *functionType) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFunction); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *functionControl3 = spv::FunctionControlMask(_instruction[_o++]); |
| *functionType = IdRef(_instruction[_o++]); |
| } |
| void ParseFunctionParameter(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFunctionParameter); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| } |
| void ParseFunctionCall(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *function, |
| IdRefList *argumentList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFunctionCall); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *function = IdRef(_instruction[_o++]); |
| if (argumentList) |
| { |
| while (_o < _length) |
| { |
| argumentList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseVariable(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| spv::StorageClass *storageClass3, |
| IdRef *initializer) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpVariable); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *storageClass3 = spv::StorageClass(_instruction[_o++]); |
| if (initializer && _o < _length) |
| { |
| *initializer = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseImageTexelPointer(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *coordinate, |
| IdRef *sample) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageTexelPointer); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *sample = IdRef(_instruction[_o++]); |
| } |
| void ParseLoad(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| spv::MemoryAccessMask *memoryAccess4) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLoad); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| if (memoryAccess4 && _o < _length) |
| { |
| *memoryAccess4 = spv::MemoryAccessMask(_instruction[_o++]); |
| } |
| } |
| void ParseStore(const uint32_t *_instruction, |
| IdRef *pointer, |
| IdRef *object, |
| spv::MemoryAccessMask *memoryAccess3) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpStore); |
| uint32_t _o = 1; |
| *pointer = IdRef(_instruction[_o++]); |
| *object = IdRef(_instruction[_o++]); |
| if (memoryAccess3 && _o < _length) |
| { |
| *memoryAccess3 = spv::MemoryAccessMask(_instruction[_o++]); |
| } |
| } |
| void ParseCopyMemory(const uint32_t *_instruction, |
| IdRef *target, |
| IdRef *source, |
| spv::MemoryAccessMask *memoryAccess3, |
| spv::MemoryAccessMask *memoryAccess4) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCopyMemory); |
| uint32_t _o = 1; |
| *target = IdRef(_instruction[_o++]); |
| *source = IdRef(_instruction[_o++]); |
| if (memoryAccess3 && _o < _length) |
| { |
| *memoryAccess3 = spv::MemoryAccessMask(_instruction[_o++]); |
| } |
| if (memoryAccess4 && _o < _length) |
| { |
| *memoryAccess4 = spv::MemoryAccessMask(_instruction[_o++]); |
| } |
| } |
| void ParseAccessChain(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRefList *indexesList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAccessChain); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| if (indexesList) |
| { |
| while (_o < _length) |
| { |
| indexesList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseInBoundsAccessChain(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRefList *indexesList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpInBoundsAccessChain); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| if (indexesList) |
| { |
| while (_o < _length) |
| { |
| indexesList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseArrayLength(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *structure, |
| LiteralInteger *arraymember) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpArrayLength); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *structure = IdRef(_instruction[_o++]); |
| *arraymember = LiteralInteger(_instruction[_o++]); |
| } |
| void ParseDecorate(const uint32_t *_instruction, |
| IdRef *target, |
| spv::Decoration *decoration2, |
| LiteralIntegerList *valuesList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDecorate); |
| uint32_t _o = 1; |
| *target = IdRef(_instruction[_o++]); |
| *decoration2 = spv::Decoration(_instruction[_o++]); |
| if (valuesList) |
| { |
| while (_o < _length) |
| { |
| valuesList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseMemberDecorate(const uint32_t *_instruction, |
| IdRef *structureType, |
| LiteralInteger *member, |
| spv::Decoration *decoration3, |
| LiteralIntegerList *valuesList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMemberDecorate); |
| uint32_t _o = 1; |
| *structureType = IdRef(_instruction[_o++]); |
| *member = LiteralInteger(_instruction[_o++]); |
| *decoration3 = spv::Decoration(_instruction[_o++]); |
| if (valuesList) |
| { |
| while (_o < _length) |
| { |
| valuesList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseDecorationGroup(const uint32_t *_instruction, IdResult *idResult1) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDecorationGroup); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| } |
| void ParseGroupDecorate(const uint32_t *_instruction, |
| IdRef *decorationGroup, |
| IdRefList *targetsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupDecorate); |
| uint32_t _o = 1; |
| *decorationGroup = IdRef(_instruction[_o++]); |
| if (targetsList) |
| { |
| while (_o < _length) |
| { |
| targetsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseGroupMemberDecorate(const uint32_t *_instruction, |
| IdRef *decorationGroup, |
| PairIdRefLiteralIntegerList *targetsPairList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupMemberDecorate); |
| uint32_t _o = 1; |
| *decorationGroup = IdRef(_instruction[_o++]); |
| if (targetsPairList) |
| { |
| while (_o < _length) |
| { |
| targetsPairList->emplace_back(PairIdRefLiteralInteger{ |
| IdRef(_instruction[_o]), LiteralInteger(_instruction[_o + 1])}); |
| _o += 2; |
| } |
| } |
| } |
| void ParseVectorExtractDynamic(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector, |
| IdRef *index) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpVectorExtractDynamic); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| *index = IdRef(_instruction[_o++]); |
| } |
| void ParseVectorInsertDynamic(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector, |
| IdRef *component, |
| IdRef *index) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpVectorInsertDynamic); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| *component = IdRef(_instruction[_o++]); |
| *index = IdRef(_instruction[_o++]); |
| } |
| void ParseVectorShuffle(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector1, |
| IdRef *vector2, |
| LiteralIntegerList *componentsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpVectorShuffle); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector1 = IdRef(_instruction[_o++]); |
| *vector2 = IdRef(_instruction[_o++]); |
| if (componentsList) |
| { |
| while (_o < _length) |
| { |
| componentsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseCompositeConstruct(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRefList *constituentsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCompositeConstruct); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| if (constituentsList) |
| { |
| while (_o < _length) |
| { |
| constituentsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseCompositeExtract(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *composite, |
| LiteralIntegerList *indexesList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCompositeExtract); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *composite = IdRef(_instruction[_o++]); |
| if (indexesList) |
| { |
| while (_o < _length) |
| { |
| indexesList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseCompositeInsert(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *object, |
| IdRef *composite, |
| LiteralIntegerList *indexesList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCompositeInsert); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *object = IdRef(_instruction[_o++]); |
| *composite = IdRef(_instruction[_o++]); |
| if (indexesList) |
| { |
| while (_o < _length) |
| { |
| indexesList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseCopyObject(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCopyObject); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParseTranspose(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *matrix) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpTranspose); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *matrix = IdRef(_instruction[_o++]); |
| } |
| void ParseSampledImage(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *sampler) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSampledImage); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *sampler = IdRef(_instruction[_o++]); |
| } |
| void ParseImageSampleImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleDrefImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleDrefImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleDrefExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleDrefExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleProjImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleProjImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleProjExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleProjExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleProjDrefImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleProjDrefImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSampleProjDrefExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSampleProjDrefExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageFetch(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageFetch); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageGather(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *component, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageGather); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *component = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageDrefGather(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageDrefGather); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageRead(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageRead); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageWrite(const uint32_t *_instruction, |
| IdRef *image, |
| IdRef *coordinate, |
| IdRef *texel, |
| spv::ImageOperandsMask *imageOperands4, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageWrite); |
| uint32_t _o = 1; |
| *image = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *texel = IdRef(_instruction[_o++]); |
| if (imageOperands4 && _o < _length) |
| { |
| *imageOperands4 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImage(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImage); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| } |
| void ParseImageQuerySizeLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *levelofDetail) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageQuerySizeLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *levelofDetail = IdRef(_instruction[_o++]); |
| } |
| void ParseImageQuerySize(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageQuerySize); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| } |
| void ParseImageQueryLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageQueryLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| } |
| void ParseImageQueryLevels(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageQueryLevels); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| } |
| void ParseImageQuerySamples(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageQuerySamples); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| } |
| void ParseConvertFToU(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *floatValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConvertFToU); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *floatValue = IdRef(_instruction[_o++]); |
| } |
| void ParseConvertFToS(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *floatValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConvertFToS); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *floatValue = IdRef(_instruction[_o++]); |
| } |
| void ParseConvertSToF(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *signedValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConvertSToF); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *signedValue = IdRef(_instruction[_o++]); |
| } |
| void ParseConvertUToF(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *unsignedValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpConvertUToF); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *unsignedValue = IdRef(_instruction[_o++]); |
| } |
| void ParseUConvert(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *unsignedValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUConvert); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *unsignedValue = IdRef(_instruction[_o++]); |
| } |
| void ParseSConvert(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *signedValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSConvert); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *signedValue = IdRef(_instruction[_o++]); |
| } |
| void ParseFConvert(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *floatValue) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFConvert); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *floatValue = IdRef(_instruction[_o++]); |
| } |
| void ParseQuantizeToF16(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpQuantizeToF16); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseBitcast(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitcast); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParseSNegate(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSNegate); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParseFNegate(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFNegate); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParseIAdd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpIAdd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFAdd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFAdd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseISub(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpISub); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFSub(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFSub); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseIMul(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpIMul); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFMul(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFMul); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseUDiv(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUDiv); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSDiv(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSDiv); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFDiv(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFDiv); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseUMod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUMod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSRem(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSRem); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSMod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSMod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFRem(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFRem); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFMod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFMod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseVectorTimesScalar(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector, |
| IdRef *scalar) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpVectorTimesScalar); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| *scalar = IdRef(_instruction[_o++]); |
| } |
| void ParseMatrixTimesScalar(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *matrix, |
| IdRef *scalar) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMatrixTimesScalar); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *matrix = IdRef(_instruction[_o++]); |
| *scalar = IdRef(_instruction[_o++]); |
| } |
| void ParseVectorTimesMatrix(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector, |
| IdRef *matrix) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpVectorTimesMatrix); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| *matrix = IdRef(_instruction[_o++]); |
| } |
| void ParseMatrixTimesVector(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *matrix, |
| IdRef *vector) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMatrixTimesVector); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *matrix = IdRef(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| } |
| void ParseMatrixTimesMatrix(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *leftMatrix, |
| IdRef *rightMatrix) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMatrixTimesMatrix); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *leftMatrix = IdRef(_instruction[_o++]); |
| *rightMatrix = IdRef(_instruction[_o++]); |
| } |
| void ParseOuterProduct(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector1, |
| IdRef *vector2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpOuterProduct); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector1 = IdRef(_instruction[_o++]); |
| *vector2 = IdRef(_instruction[_o++]); |
| } |
| void ParseDot(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector1, |
| IdRef *vector2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDot); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector1 = IdRef(_instruction[_o++]); |
| *vector2 = IdRef(_instruction[_o++]); |
| } |
| void ParseIAddCarry(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpIAddCarry); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseISubBorrow(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpISubBorrow); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseUMulExtended(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUMulExtended); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSMulExtended(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSMulExtended); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseAny(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAny); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| } |
| void ParseAll(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *vector) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAll); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *vector = IdRef(_instruction[_o++]); |
| } |
| void ParseIsNan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *x) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpIsNan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *x = IdRef(_instruction[_o++]); |
| } |
| void ParseIsInf(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *x) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpIsInf); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *x = IdRef(_instruction[_o++]); |
| } |
| void ParseLogicalEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLogicalEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseLogicalNotEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLogicalNotEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseLogicalOr(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLogicalOr); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseLogicalAnd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLogicalAnd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseLogicalNot(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLogicalNot); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParseSelect(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *condition, |
| IdRef *object1, |
| IdRef *object2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSelect); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *condition = IdRef(_instruction[_o++]); |
| *object1 = IdRef(_instruction[_o++]); |
| *object2 = IdRef(_instruction[_o++]); |
| } |
| void ParseIEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpIEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseINotEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpINotEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseUGreaterThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUGreaterThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSGreaterThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSGreaterThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseUGreaterThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpUGreaterThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSGreaterThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSGreaterThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseULessThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpULessThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSLessThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSLessThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseULessThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpULessThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseSLessThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSLessThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFOrdEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFOrdEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFUnordEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFUnordEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFOrdNotEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFOrdNotEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFUnordNotEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFUnordNotEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFOrdLessThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFOrdLessThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFUnordLessThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFUnordLessThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFOrdGreaterThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFOrdGreaterThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFUnordGreaterThan(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFUnordGreaterThan); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFOrdLessThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFOrdLessThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFUnordLessThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFUnordLessThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFOrdGreaterThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFOrdGreaterThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseFUnordGreaterThanEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFUnordGreaterThanEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseShiftRightLogical(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRef *shift) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpShiftRightLogical); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| *shift = IdRef(_instruction[_o++]); |
| } |
| void ParseShiftRightArithmetic(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRef *shift) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpShiftRightArithmetic); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| *shift = IdRef(_instruction[_o++]); |
| } |
| void ParseShiftLeftLogical(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRef *shift) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpShiftLeftLogical); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| *shift = IdRef(_instruction[_o++]); |
| } |
| void ParseBitwiseOr(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitwiseOr); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseBitwiseXor(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitwiseXor); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseBitwiseAnd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitwiseAnd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParseNot(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpNot); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParseBitFieldInsert(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRef *insert, |
| IdRef *offset, |
| IdRef *count) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitFieldInsert); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| *insert = IdRef(_instruction[_o++]); |
| *offset = IdRef(_instruction[_o++]); |
| *count = IdRef(_instruction[_o++]); |
| } |
| void ParseBitFieldSExtract(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRef *offset, |
| IdRef *count) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitFieldSExtract); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| *offset = IdRef(_instruction[_o++]); |
| *count = IdRef(_instruction[_o++]); |
| } |
| void ParseBitFieldUExtract(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base, |
| IdRef *offset, |
| IdRef *count) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitFieldUExtract); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| *offset = IdRef(_instruction[_o++]); |
| *count = IdRef(_instruction[_o++]); |
| } |
| void ParseBitReverse(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitReverse); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| } |
| void ParseBitCount(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *base) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBitCount); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *base = IdRef(_instruction[_o++]); |
| } |
| void ParseDPdx(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDPdx); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseDPdy(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDPdy); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseFwidth(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFwidth); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseDPdxFine(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDPdxFine); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseDPdyFine(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDPdyFine); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseFwidthFine(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFwidthFine); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseDPdxCoarse(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDPdxCoarse); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseDPdyCoarse(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpDPdyCoarse); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseFwidthCoarse(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *p) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpFwidthCoarse); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *p = IdRef(_instruction[_o++]); |
| } |
| void ParseEmitStreamVertex(const uint32_t *_instruction, IdRef *stream) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpEmitStreamVertex); |
| uint32_t _o = 1; |
| *stream = IdRef(_instruction[_o++]); |
| } |
| void ParseEndStreamPrimitive(const uint32_t *_instruction, IdRef *stream) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpEndStreamPrimitive); |
| uint32_t _o = 1; |
| *stream = IdRef(_instruction[_o++]); |
| } |
| void ParseControlBarrier(const uint32_t *_instruction, |
| IdScope *execution, |
| IdScope *memory, |
| IdMemorySemantics *semantics) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpControlBarrier); |
| uint32_t _o = 1; |
| *execution = IdScope(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| } |
| void ParseMemoryBarrier(const uint32_t *_instruction, IdScope *memory, IdMemorySemantics *semantics) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpMemoryBarrier); |
| uint32_t _o = 1; |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| } |
| void ParseAtomicLoad(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicLoad); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| } |
| void ParseAtomicStore(const uint32_t *_instruction, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicStore); |
| uint32_t _o = 1; |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicExchange(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicExchange); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicCompareExchange(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *equal, |
| IdMemorySemantics *unequal, |
| IdRef *value, |
| IdRef *comparator) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicCompareExchange); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *equal = IdMemorySemantics(_instruction[_o++]); |
| *unequal = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *comparator = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicIIncrement(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicIIncrement); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| } |
| void ParseAtomicIDecrement(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicIDecrement); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| } |
| void ParseAtomicIAdd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicIAdd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicISub(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicISub); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicSMin(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicSMin); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicUMin(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicUMin); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicSMax(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicSMax); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicUMax(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicUMax); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicAnd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicAnd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicOr(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicOr); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseAtomicXor(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *pointer, |
| IdScope *memory, |
| IdMemorySemantics *semantics, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpAtomicXor); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *pointer = IdRef(_instruction[_o++]); |
| *memory = IdScope(_instruction[_o++]); |
| *semantics = IdMemorySemantics(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParsePhi(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| PairIdRefIdRefList *variableParentPairList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpPhi); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| if (variableParentPairList) |
| { |
| while (_o < _length) |
| { |
| variableParentPairList->emplace_back( |
| PairIdRefIdRef{IdRef(_instruction[_o]), IdRef(_instruction[_o + 1])}); |
| _o += 2; |
| } |
| } |
| } |
| void ParseLoopMerge(const uint32_t *_instruction, |
| IdRef *mergeBlock, |
| IdRef *continueTarget, |
| spv::LoopControlMask *loopControl3) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLoopMerge); |
| uint32_t _o = 1; |
| *mergeBlock = IdRef(_instruction[_o++]); |
| *continueTarget = IdRef(_instruction[_o++]); |
| *loopControl3 = spv::LoopControlMask(_instruction[_o++]); |
| } |
| void ParseSelectionMerge(const uint32_t *_instruction, |
| IdRef *mergeBlock, |
| spv::SelectionControlMask *selectionControl2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSelectionMerge); |
| uint32_t _o = 1; |
| *mergeBlock = IdRef(_instruction[_o++]); |
| *selectionControl2 = spv::SelectionControlMask(_instruction[_o++]); |
| } |
| void ParseLabel(const uint32_t *_instruction, IdResult *idResult1) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpLabel); |
| uint32_t _o = 1; |
| *idResult1 = IdResult(_instruction[_o++]); |
| } |
| void ParseBranch(const uint32_t *_instruction, IdRef *targetLabel) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBranch); |
| uint32_t _o = 1; |
| *targetLabel = IdRef(_instruction[_o++]); |
| } |
| void ParseBranchConditional(const uint32_t *_instruction, |
| IdRef *condition, |
| IdRef *trueLabel, |
| IdRef *falseLabel, |
| LiteralIntegerList *branchweightsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpBranchConditional); |
| uint32_t _o = 1; |
| *condition = IdRef(_instruction[_o++]); |
| *trueLabel = IdRef(_instruction[_o++]); |
| *falseLabel = IdRef(_instruction[_o++]); |
| if (branchweightsList) |
| { |
| while (_o < _length) |
| { |
| branchweightsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseSwitch(const uint32_t *_instruction, |
| IdRef *selector, |
| IdRef *default_, |
| PairLiteralIntegerIdRefList *targetPairList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpSwitch); |
| uint32_t _o = 1; |
| *selector = IdRef(_instruction[_o++]); |
| *default_ = IdRef(_instruction[_o++]); |
| if (targetPairList) |
| { |
| while (_o < _length) |
| { |
| targetPairList->emplace_back(PairLiteralIntegerIdRef{LiteralInteger(_instruction[_o]), |
| IdRef(_instruction[_o + 1])}); |
| _o += 2; |
| } |
| } |
| } |
| void ParseReturnValue(const uint32_t *_instruction, IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpReturnValue); |
| uint32_t _o = 1; |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseImageSparseSampleImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleDrefImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleDrefImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleDrefExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleDrefExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleProjImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleProjImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleProjExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleProjExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleProjDrefImplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleProjDrefImplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseSampleProjDrefExplicitLod(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseSampleProjDrefExplicitLod); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseFetch(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseFetch); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseGather(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *component, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseGather); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *component = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseDrefGather(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *sampledImage, |
| IdRef *coordinate, |
| IdRef *dref, |
| spv::ImageOperandsMask *imageOperands6, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseDrefGather); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *sampledImage = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| *dref = IdRef(_instruction[_o++]); |
| if (imageOperands6 && _o < _length) |
| { |
| *imageOperands6 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseImageSparseTexelsResident(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *residentCode) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseTexelsResident); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *residentCode = IdRef(_instruction[_o++]); |
| } |
| void ParseImageSparseRead(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *image, |
| IdRef *coordinate, |
| spv::ImageOperandsMask *imageOperands5, |
| IdRefList *imageOperandIdsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpImageSparseRead); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *image = IdRef(_instruction[_o++]); |
| *coordinate = IdRef(_instruction[_o++]); |
| if (imageOperands5 && _o < _length) |
| { |
| *imageOperands5 = spv::ImageOperandsMask(_instruction[_o++]); |
| } |
| if (imageOperandIdsList) |
| { |
| while (_o < _length) |
| { |
| imageOperandIdsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseModuleProcessed(const uint32_t *_instruction, LiteralString *process) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpModuleProcessed); |
| uint32_t _o = 1; |
| ASSERT(IsLittleEndian()); |
| *process = reinterpret_cast<const char *>(&_instruction[_o]); |
| _o += strlen(*process) / 4 + 1; |
| } |
| void ParseExecutionModeId(const uint32_t *_instruction, |
| IdRef *entryPoint, |
| spv::ExecutionMode *mode, |
| LiteralIntegerList *operandsList) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpExecutionModeId); |
| uint32_t _o = 1; |
| *entryPoint = IdRef(_instruction[_o++]); |
| *mode = spv::ExecutionMode(_instruction[_o++]); |
| if (operandsList) |
| { |
| while (_o < _length) |
| { |
| operandsList->emplace_back(_instruction[_o++]); |
| } |
| } |
| } |
| void ParseGroupNonUniformElect(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformElect); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformAll(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *predicate) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformAll); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *predicate = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformAny(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *predicate) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformAny); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *predicate = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformAllEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformAllEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBroadcast(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *id) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBroadcast); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *id = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBroadcastFirst(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBroadcastFirst); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBallot(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *predicate) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBallot); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *predicate = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformInverseBallot(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformInverseBallot); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBallotBitExtract(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *index) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBallotBitExtract); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *index = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBallotBitCount(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBallotBitCount); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBallotFindLSB(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBallotFindLSB); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformBallotFindMSB(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBallotFindMSB); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformShuffle(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *id) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformShuffle); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *id = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformShuffleXor(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *mask) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformShuffleXor); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *mask = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformShuffleUp(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *delta) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformShuffleUp); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *delta = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformShuffleDown(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *delta) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformShuffleDown); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *delta = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformIAdd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformIAdd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformFAdd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformFAdd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformIMul(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformIMul); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformFMul(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformFMul); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformSMin(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformSMin); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformUMin(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformUMin); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformFMin(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformFMin); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformSMax(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformSMax); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformUMax(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformUMax); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformFMax(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformFMax); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformBitwiseAnd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBitwiseAnd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformBitwiseOr(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBitwiseOr); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformBitwiseXor(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformBitwiseXor); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformLogicalAnd(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformLogicalAnd); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformLogicalOr(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformLogicalOr); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformLogicalXor(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| spv::GroupOperation *operation, |
| IdRef *value, |
| IdRef *clusterSize) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformLogicalXor); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *operation = spv::GroupOperation(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| if (clusterSize && _o < _length) |
| { |
| *clusterSize = IdRef(_instruction[_o++]); |
| } |
| } |
| void ParseGroupNonUniformQuadBroadcast(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *index) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformQuadBroadcast); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *index = IdRef(_instruction[_o++]); |
| } |
| void ParseGroupNonUniformQuadSwap(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdScope *execution, |
| IdRef *value, |
| IdRef *direction) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpGroupNonUniformQuadSwap); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *execution = IdScope(_instruction[_o++]); |
| *value = IdRef(_instruction[_o++]); |
| *direction = IdRef(_instruction[_o++]); |
| } |
| void ParseCopyLogical(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpCopyLogical); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand = IdRef(_instruction[_o++]); |
| } |
| void ParsePtrEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpPtrEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| void ParsePtrNotEqual(const uint32_t *_instruction, |
| IdResultType *idResultType1, |
| IdResult *idResult2, |
| IdRef *operand1, |
| IdRef *operand2) |
| { |
| spv::Op _op; |
| uint32_t _length; |
| GetInstructionOpAndLength(_instruction, &_op, &_length); |
| ASSERT(_op == spv::OpPtrNotEqual); |
| uint32_t _o = 1; |
| *idResultType1 = IdResultType(_instruction[_o++]); |
| *idResult2 = IdResult(_instruction[_o++]); |
| *operand1 = IdRef(_instruction[_o++]); |
| *operand2 = IdRef(_instruction[_o++]); |
| } |
| |
| } // namespace spirv |
| } // namespace angle |
