| // Copyright (c) 2015-2020 The Khronos Group Inc. |
| // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights |
| // reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "source/opcode.h" |
| |
| #include <assert.h> |
| #include <string.h> |
| |
| #include <algorithm> |
| #include <cstdlib> |
| |
| #include "source/instruction.h" |
| #include "source/macro.h" |
| #include "source/spirv_constant.h" |
| #include "source/spirv_endian.h" |
| #include "source/spirv_target_env.h" |
| #include "spirv-tools/libspirv.h" |
| |
| namespace { |
| struct OpcodeDescPtrLen { |
| const spv_opcode_desc_t* ptr; |
| uint32_t len; |
| }; |
| |
| #include "core.insts-unified1.inc" |
| |
| static const spv_opcode_table_t kOpcodeTable = {ARRAY_SIZE(kOpcodeTableEntries), |
| kOpcodeTableEntries}; |
| |
| // Represents a vendor tool entry in the SPIR-V XML Regsitry. |
| struct VendorTool { |
| uint32_t value; |
| const char* vendor; |
| const char* tool; // Might be empty string. |
| const char* vendor_tool; // Combiantion of vendor and tool. |
| }; |
| |
| const VendorTool vendor_tools[] = { |
| #include "generators.inc" |
| }; |
| |
| } // anonymous namespace |
| |
| // TODO(dneto): Move this to another file. It doesn't belong with opcode |
| // processing. |
| const char* spvGeneratorStr(uint32_t generator) { |
| auto where = std::find_if( |
| std::begin(vendor_tools), std::end(vendor_tools), |
| [generator](const VendorTool& vt) { return generator == vt.value; }); |
| if (where != std::end(vendor_tools)) return where->vendor_tool; |
| return "Unknown"; |
| } |
| |
| uint32_t spvOpcodeMake(uint16_t wordCount, SpvOp opcode) { |
| return ((uint32_t)opcode) | (((uint32_t)wordCount) << 16); |
| } |
| |
| void spvOpcodeSplit(const uint32_t word, uint16_t* pWordCount, |
| uint16_t* pOpcode) { |
| if (pWordCount) { |
| *pWordCount = (uint16_t)((0xffff0000 & word) >> 16); |
| } |
| if (pOpcode) { |
| *pOpcode = 0x0000ffff & word; |
| } |
| } |
| |
| spv_result_t spvOpcodeTableGet(spv_opcode_table* pInstTable, spv_target_env) { |
| if (!pInstTable) return SPV_ERROR_INVALID_POINTER; |
| |
| // Descriptions of each opcode. Each entry describes the format of the |
| // instruction that follows a particular opcode. |
| |
| *pInstTable = &kOpcodeTable; |
| return SPV_SUCCESS; |
| } |
| |
| spv_result_t spvOpcodeTableNameLookup(spv_target_env env, |
| const spv_opcode_table table, |
| const char* name, |
| spv_opcode_desc* pEntry) { |
| if (!name || !pEntry) return SPV_ERROR_INVALID_POINTER; |
| if (!table) return SPV_ERROR_INVALID_TABLE; |
| |
| // TODO: This lookup of the Opcode table is suboptimal! Binary sort would be |
| // preferable but the table requires sorting on the Opcode name, but it's |
| // static const initialized and matches the order of the spec. |
| const size_t nameLength = strlen(name); |
| const auto version = spvVersionForTargetEnv(env); |
| for (uint64_t opcodeIndex = 0; opcodeIndex < table->count; ++opcodeIndex) { |
| const spv_opcode_desc_t& entry = table->entries[opcodeIndex]; |
| // We considers the current opcode as available as long as |
| // 1. The target environment satisfies the minimal requirement of the |
| // opcode; or |
| // 2. There is at least one extension enabling this opcode. |
| // |
| // Note that the second rule assumes the extension enabling this instruction |
| // is indeed requested in the SPIR-V code; checking that should be |
| // validator's work. |
| if (((version >= entry.minVersion && version <= entry.lastVersion) || |
| entry.numExtensions > 0u || entry.numCapabilities > 0u) && |
| nameLength == strlen(entry.name) && |
| !strncmp(name, entry.name, nameLength)) { |
| // NOTE: Found out Opcode! |
| *pEntry = &entry; |
| return SPV_SUCCESS; |
| } |
| } |
| |
| return SPV_ERROR_INVALID_LOOKUP; |
| } |
| |
| spv_result_t spvOpcodeTableValueLookup(spv_target_env env, |
| const spv_opcode_table table, |
| const SpvOp opcode, |
| spv_opcode_desc* pEntry) { |
| if (!table) return SPV_ERROR_INVALID_TABLE; |
| if (!pEntry) return SPV_ERROR_INVALID_POINTER; |
| |
| const auto beg = table->entries; |
| const auto end = table->entries + table->count; |
| |
| spv_opcode_desc_t needle = {"", opcode, 0, nullptr, 0, {}, |
| false, false, 0, nullptr, ~0u, ~0u}; |
| |
| auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) { |
| return lhs.opcode < rhs.opcode; |
| }; |
| |
| // We need to loop here because there can exist multiple symbols for the same |
| // opcode value, and they can be introduced in different target environments, |
| // which means they can have different minimal version requirements. |
| // Assumes the underlying table is already sorted ascendingly according to |
| // opcode value. |
| const auto version = spvVersionForTargetEnv(env); |
| for (auto it = std::lower_bound(beg, end, needle, comp); |
| it != end && it->opcode == opcode; ++it) { |
| // We considers the current opcode as available as long as |
| // 1. The target environment satisfies the minimal requirement of the |
| // opcode; or |
| // 2. There is at least one extension enabling this opcode. |
| // |
| // Note that the second rule assumes the extension enabling this instruction |
| // is indeed requested in the SPIR-V code; checking that should be |
| // validator's work. |
| if ((version >= it->minVersion && version <= it->lastVersion) || |
| it->numExtensions > 0u || it->numCapabilities > 0u) { |
| *pEntry = it; |
| return SPV_SUCCESS; |
| } |
| } |
| |
| return SPV_ERROR_INVALID_LOOKUP; |
| } |
| |
| void spvInstructionCopy(const uint32_t* words, const SpvOp opcode, |
| const uint16_t wordCount, const spv_endianness_t endian, |
| spv_instruction_t* pInst) { |
| pInst->opcode = opcode; |
| pInst->words.resize(wordCount); |
| for (uint16_t wordIndex = 0; wordIndex < wordCount; ++wordIndex) { |
| pInst->words[wordIndex] = spvFixWord(words[wordIndex], endian); |
| if (!wordIndex) { |
| uint16_t thisWordCount; |
| uint16_t thisOpcode; |
| spvOpcodeSplit(pInst->words[wordIndex], &thisWordCount, &thisOpcode); |
| assert(opcode == static_cast<SpvOp>(thisOpcode) && |
| wordCount == thisWordCount && "Endianness failed!"); |
| } |
| } |
| } |
| |
| const char* spvOpcodeString(const uint32_t opcode) { |
| const auto beg = kOpcodeTableEntries; |
| const auto end = kOpcodeTableEntries + ARRAY_SIZE(kOpcodeTableEntries); |
| spv_opcode_desc_t needle = {"", static_cast<SpvOp>(opcode), |
| 0, nullptr, |
| 0, {}, |
| false, false, |
| 0, nullptr, |
| ~0u, ~0u}; |
| auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) { |
| return lhs.opcode < rhs.opcode; |
| }; |
| auto it = std::lower_bound(beg, end, needle, comp); |
| if (it != end && it->opcode == opcode) { |
| return it->name; |
| } |
| |
| assert(0 && "Unreachable!"); |
| return "unknown"; |
| } |
| |
| int32_t spvOpcodeIsScalarType(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpTypeInt: |
| case SpvOpTypeFloat: |
| case SpvOpTypeBool: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| int32_t spvOpcodeIsSpecConstant(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpSpecConstantTrue: |
| case SpvOpSpecConstantFalse: |
| case SpvOpSpecConstant: |
| case SpvOpSpecConstantComposite: |
| case SpvOpSpecConstantOp: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| int32_t spvOpcodeIsConstant(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpConstantTrue: |
| case SpvOpConstantFalse: |
| case SpvOpConstant: |
| case SpvOpConstantComposite: |
| case SpvOpConstantSampler: |
| case SpvOpConstantNull: |
| case SpvOpSpecConstantTrue: |
| case SpvOpSpecConstantFalse: |
| case SpvOpSpecConstant: |
| case SpvOpSpecConstantComposite: |
| case SpvOpSpecConstantOp: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsConstantOrUndef(const SpvOp opcode) { |
| return opcode == SpvOpUndef || spvOpcodeIsConstant(opcode); |
| } |
| |
| bool spvOpcodeIsScalarSpecConstant(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpSpecConstantTrue: |
| case SpvOpSpecConstantFalse: |
| case SpvOpSpecConstant: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| int32_t spvOpcodeIsComposite(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpTypeVector: |
| case SpvOpTypeMatrix: |
| case SpvOpTypeArray: |
| case SpvOpTypeStruct: |
| case SpvOpTypeCooperativeMatrixNV: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeReturnsLogicalVariablePointer(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpVariable: |
| case SpvOpAccessChain: |
| case SpvOpInBoundsAccessChain: |
| case SpvOpFunctionParameter: |
| case SpvOpImageTexelPointer: |
| case SpvOpCopyObject: |
| case SpvOpSelect: |
| case SpvOpPhi: |
| case SpvOpFunctionCall: |
| case SpvOpPtrAccessChain: |
| case SpvOpLoad: |
| case SpvOpConstantNull: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| int32_t spvOpcodeReturnsLogicalPointer(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpVariable: |
| case SpvOpAccessChain: |
| case SpvOpInBoundsAccessChain: |
| case SpvOpFunctionParameter: |
| case SpvOpImageTexelPointer: |
| case SpvOpCopyObject: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| int32_t spvOpcodeGeneratesType(SpvOp op) { |
| switch (op) { |
| case SpvOpTypeVoid: |
| case SpvOpTypeBool: |
| case SpvOpTypeInt: |
| case SpvOpTypeFloat: |
| case SpvOpTypeVector: |
| case SpvOpTypeMatrix: |
| case SpvOpTypeImage: |
| case SpvOpTypeSampler: |
| case SpvOpTypeSampledImage: |
| case SpvOpTypeArray: |
| case SpvOpTypeRuntimeArray: |
| case SpvOpTypeStruct: |
| case SpvOpTypeOpaque: |
| case SpvOpTypePointer: |
| case SpvOpTypeFunction: |
| case SpvOpTypeEvent: |
| case SpvOpTypeDeviceEvent: |
| case SpvOpTypeReserveId: |
| case SpvOpTypeQueue: |
| case SpvOpTypePipe: |
| case SpvOpTypePipeStorage: |
| case SpvOpTypeNamedBarrier: |
| case SpvOpTypeAccelerationStructureNV: |
| case SpvOpTypeCooperativeMatrixNV: |
| // case SpvOpTypeAccelerationStructureKHR: covered by |
| // SpvOpTypeAccelerationStructureNV |
| case SpvOpTypeRayQueryKHR: |
| return true; |
| default: |
| // In particular, OpTypeForwardPointer does not generate a type, |
| // but declares a storage class for a pointer type generated |
| // by a different instruction. |
| break; |
| } |
| return 0; |
| } |
| |
| bool spvOpcodeIsDecoration(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpDecorate: |
| case SpvOpDecorateId: |
| case SpvOpMemberDecorate: |
| case SpvOpGroupDecorate: |
| case SpvOpGroupMemberDecorate: |
| case SpvOpDecorateStringGOOGLE: |
| case SpvOpMemberDecorateStringGOOGLE: |
| return true; |
| default: |
| break; |
| } |
| return false; |
| } |
| |
| bool spvOpcodeIsLoad(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpLoad: |
| case SpvOpImageSampleExplicitLod: |
| case SpvOpImageSampleImplicitLod: |
| case SpvOpImageSampleDrefImplicitLod: |
| case SpvOpImageSampleDrefExplicitLod: |
| case SpvOpImageSampleProjImplicitLod: |
| case SpvOpImageSampleProjExplicitLod: |
| case SpvOpImageSampleProjDrefImplicitLod: |
| case SpvOpImageSampleProjDrefExplicitLod: |
| case SpvOpImageFetch: |
| case SpvOpImageGather: |
| case SpvOpImageDrefGather: |
| case SpvOpImageRead: |
| case SpvOpImageSparseSampleImplicitLod: |
| case SpvOpImageSparseSampleExplicitLod: |
| case SpvOpImageSparseSampleDrefExplicitLod: |
| case SpvOpImageSparseSampleDrefImplicitLod: |
| case SpvOpImageSparseFetch: |
| case SpvOpImageSparseGather: |
| case SpvOpImageSparseDrefGather: |
| case SpvOpImageSparseRead: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsBranch(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpBranch: |
| case SpvOpBranchConditional: |
| case SpvOpSwitch: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsAtomicWithLoad(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpAtomicLoad: |
| case SpvOpAtomicExchange: |
| case SpvOpAtomicCompareExchange: |
| case SpvOpAtomicCompareExchangeWeak: |
| case SpvOpAtomicIIncrement: |
| case SpvOpAtomicIDecrement: |
| case SpvOpAtomicIAdd: |
| case SpvOpAtomicFAddEXT: |
| case SpvOpAtomicISub: |
| case SpvOpAtomicSMin: |
| case SpvOpAtomicUMin: |
| case SpvOpAtomicFMinEXT: |
| case SpvOpAtomicSMax: |
| case SpvOpAtomicUMax: |
| case SpvOpAtomicFMaxEXT: |
| case SpvOpAtomicAnd: |
| case SpvOpAtomicOr: |
| case SpvOpAtomicXor: |
| case SpvOpAtomicFlagTestAndSet: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsAtomicOp(const SpvOp opcode) { |
| return (spvOpcodeIsAtomicWithLoad(opcode) || opcode == SpvOpAtomicStore || |
| opcode == SpvOpAtomicFlagClear); |
| } |
| |
| bool spvOpcodeIsReturn(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpReturn: |
| case SpvOpReturnValue: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsAbort(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpKill: |
| case SpvOpUnreachable: |
| case SpvOpTerminateInvocation: |
| case SpvOpTerminateRayKHR: |
| case SpvOpIgnoreIntersectionKHR: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsReturnOrAbort(SpvOp opcode) { |
| return spvOpcodeIsReturn(opcode) || spvOpcodeIsAbort(opcode); |
| } |
| |
| bool spvOpcodeIsBlockTerminator(SpvOp opcode) { |
| return spvOpcodeIsBranch(opcode) || spvOpcodeIsReturnOrAbort(opcode); |
| } |
| |
| bool spvOpcodeTerminatesExecution(SpvOp opcode) { |
| return opcode == SpvOpKill || opcode == SpvOpTerminateInvocation || |
| opcode == SpvOpTerminateRayKHR || opcode == SpvOpIgnoreIntersectionKHR; |
| } |
| |
| bool spvOpcodeIsBaseOpaqueType(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpTypeImage: |
| case SpvOpTypeSampler: |
| case SpvOpTypeSampledImage: |
| case SpvOpTypeOpaque: |
| case SpvOpTypeEvent: |
| case SpvOpTypeDeviceEvent: |
| case SpvOpTypeReserveId: |
| case SpvOpTypeQueue: |
| case SpvOpTypePipe: |
| case SpvOpTypeForwardPointer: |
| case SpvOpTypePipeStorage: |
| case SpvOpTypeNamedBarrier: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsNonUniformGroupOperation(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpGroupNonUniformElect: |
| case SpvOpGroupNonUniformAll: |
| case SpvOpGroupNonUniformAny: |
| case SpvOpGroupNonUniformAllEqual: |
| case SpvOpGroupNonUniformBroadcast: |
| case SpvOpGroupNonUniformBroadcastFirst: |
| case SpvOpGroupNonUniformBallot: |
| case SpvOpGroupNonUniformInverseBallot: |
| case SpvOpGroupNonUniformBallotBitExtract: |
| case SpvOpGroupNonUniformBallotBitCount: |
| case SpvOpGroupNonUniformBallotFindLSB: |
| case SpvOpGroupNonUniformBallotFindMSB: |
| case SpvOpGroupNonUniformShuffle: |
| case SpvOpGroupNonUniformShuffleXor: |
| case SpvOpGroupNonUniformShuffleUp: |
| case SpvOpGroupNonUniformShuffleDown: |
| case SpvOpGroupNonUniformIAdd: |
| case SpvOpGroupNonUniformFAdd: |
| case SpvOpGroupNonUniformIMul: |
| case SpvOpGroupNonUniformFMul: |
| case SpvOpGroupNonUniformSMin: |
| case SpvOpGroupNonUniformUMin: |
| case SpvOpGroupNonUniformFMin: |
| case SpvOpGroupNonUniformSMax: |
| case SpvOpGroupNonUniformUMax: |
| case SpvOpGroupNonUniformFMax: |
| case SpvOpGroupNonUniformBitwiseAnd: |
| case SpvOpGroupNonUniformBitwiseOr: |
| case SpvOpGroupNonUniformBitwiseXor: |
| case SpvOpGroupNonUniformLogicalAnd: |
| case SpvOpGroupNonUniformLogicalOr: |
| case SpvOpGroupNonUniformLogicalXor: |
| case SpvOpGroupNonUniformQuadBroadcast: |
| case SpvOpGroupNonUniformQuadSwap: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsScalarizable(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpPhi: |
| case SpvOpCopyObject: |
| case SpvOpConvertFToU: |
| case SpvOpConvertFToS: |
| case SpvOpConvertSToF: |
| case SpvOpConvertUToF: |
| case SpvOpUConvert: |
| case SpvOpSConvert: |
| case SpvOpFConvert: |
| case SpvOpQuantizeToF16: |
| case SpvOpVectorInsertDynamic: |
| case SpvOpSNegate: |
| case SpvOpFNegate: |
| case SpvOpIAdd: |
| case SpvOpFAdd: |
| case SpvOpISub: |
| case SpvOpFSub: |
| case SpvOpIMul: |
| case SpvOpFMul: |
| case SpvOpUDiv: |
| case SpvOpSDiv: |
| case SpvOpFDiv: |
| case SpvOpUMod: |
| case SpvOpSRem: |
| case SpvOpSMod: |
| case SpvOpFRem: |
| case SpvOpFMod: |
| case SpvOpVectorTimesScalar: |
| case SpvOpIAddCarry: |
| case SpvOpISubBorrow: |
| case SpvOpUMulExtended: |
| case SpvOpSMulExtended: |
| case SpvOpShiftRightLogical: |
| case SpvOpShiftRightArithmetic: |
| case SpvOpShiftLeftLogical: |
| case SpvOpBitwiseOr: |
| case SpvOpBitwiseAnd: |
| case SpvOpNot: |
| case SpvOpBitFieldInsert: |
| case SpvOpBitFieldSExtract: |
| case SpvOpBitFieldUExtract: |
| case SpvOpBitReverse: |
| case SpvOpBitCount: |
| case SpvOpIsNan: |
| case SpvOpIsInf: |
| case SpvOpIsFinite: |
| case SpvOpIsNormal: |
| case SpvOpSignBitSet: |
| case SpvOpLessOrGreater: |
| case SpvOpOrdered: |
| case SpvOpUnordered: |
| case SpvOpLogicalEqual: |
| case SpvOpLogicalNotEqual: |
| case SpvOpLogicalOr: |
| case SpvOpLogicalAnd: |
| case SpvOpLogicalNot: |
| case SpvOpSelect: |
| case SpvOpIEqual: |
| case SpvOpINotEqual: |
| case SpvOpUGreaterThan: |
| case SpvOpSGreaterThan: |
| case SpvOpUGreaterThanEqual: |
| case SpvOpSGreaterThanEqual: |
| case SpvOpULessThan: |
| case SpvOpSLessThan: |
| case SpvOpULessThanEqual: |
| case SpvOpSLessThanEqual: |
| case SpvOpFOrdEqual: |
| case SpvOpFUnordEqual: |
| case SpvOpFOrdNotEqual: |
| case SpvOpFUnordNotEqual: |
| case SpvOpFOrdLessThan: |
| case SpvOpFUnordLessThan: |
| case SpvOpFOrdGreaterThan: |
| case SpvOpFUnordGreaterThan: |
| case SpvOpFOrdLessThanEqual: |
| case SpvOpFUnordLessThanEqual: |
| case SpvOpFOrdGreaterThanEqual: |
| case SpvOpFUnordGreaterThanEqual: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsDebug(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpName: |
| case SpvOpMemberName: |
| case SpvOpSource: |
| case SpvOpSourceContinued: |
| case SpvOpSourceExtension: |
| case SpvOpString: |
| case SpvOpLine: |
| case SpvOpNoLine: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsCommutativeBinaryOperator(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpPtrEqual: |
| case SpvOpPtrNotEqual: |
| case SpvOpIAdd: |
| case SpvOpFAdd: |
| case SpvOpIMul: |
| case SpvOpFMul: |
| case SpvOpDot: |
| case SpvOpIAddCarry: |
| case SpvOpUMulExtended: |
| case SpvOpSMulExtended: |
| case SpvOpBitwiseOr: |
| case SpvOpBitwiseXor: |
| case SpvOpBitwiseAnd: |
| case SpvOpOrdered: |
| case SpvOpUnordered: |
| case SpvOpLogicalEqual: |
| case SpvOpLogicalNotEqual: |
| case SpvOpLogicalOr: |
| case SpvOpLogicalAnd: |
| case SpvOpIEqual: |
| case SpvOpINotEqual: |
| case SpvOpFOrdEqual: |
| case SpvOpFUnordEqual: |
| case SpvOpFOrdNotEqual: |
| case SpvOpFUnordNotEqual: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsLinearAlgebra(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpTranspose: |
| case SpvOpVectorTimesScalar: |
| case SpvOpMatrixTimesScalar: |
| case SpvOpVectorTimesMatrix: |
| case SpvOpMatrixTimesVector: |
| case SpvOpMatrixTimesMatrix: |
| case SpvOpOuterProduct: |
| case SpvOpDot: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsImageSample(const SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpImageSampleImplicitLod: |
| case SpvOpImageSampleExplicitLod: |
| case SpvOpImageSampleDrefImplicitLod: |
| case SpvOpImageSampleDrefExplicitLod: |
| case SpvOpImageSampleProjImplicitLod: |
| case SpvOpImageSampleProjExplicitLod: |
| case SpvOpImageSampleProjDrefImplicitLod: |
| case SpvOpImageSampleProjDrefExplicitLod: |
| case SpvOpImageSparseSampleImplicitLod: |
| case SpvOpImageSparseSampleExplicitLod: |
| case SpvOpImageSparseSampleDrefImplicitLod: |
| case SpvOpImageSparseSampleDrefExplicitLod: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| std::vector<uint32_t> spvOpcodeMemorySemanticsOperandIndices(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpMemoryBarrier: |
| return {1}; |
| case SpvOpAtomicStore: |
| case SpvOpControlBarrier: |
| case SpvOpAtomicFlagClear: |
| case SpvOpMemoryNamedBarrier: |
| return {2}; |
| case SpvOpAtomicLoad: |
| case SpvOpAtomicExchange: |
| case SpvOpAtomicIIncrement: |
| case SpvOpAtomicIDecrement: |
| case SpvOpAtomicIAdd: |
| case SpvOpAtomicFAddEXT: |
| case SpvOpAtomicISub: |
| case SpvOpAtomicSMin: |
| case SpvOpAtomicUMin: |
| case SpvOpAtomicSMax: |
| case SpvOpAtomicUMax: |
| case SpvOpAtomicAnd: |
| case SpvOpAtomicOr: |
| case SpvOpAtomicXor: |
| case SpvOpAtomicFlagTestAndSet: |
| return {4}; |
| case SpvOpAtomicCompareExchange: |
| case SpvOpAtomicCompareExchangeWeak: |
| return {4, 5}; |
| default: |
| return {}; |
| } |
| } |
| |
| bool spvOpcodeIsAccessChain(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpAccessChain: |
| case SpvOpInBoundsAccessChain: |
| case SpvOpPtrAccessChain: |
| case SpvOpInBoundsPtrAccessChain: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool spvOpcodeIsBit(SpvOp opcode) { |
| switch (opcode) { |
| case SpvOpShiftRightLogical: |
| case SpvOpShiftRightArithmetic: |
| case SpvOpShiftLeftLogical: |
| case SpvOpBitwiseOr: |
| case SpvOpBitwiseXor: |
| case SpvOpBitwiseAnd: |
| case SpvOpNot: |
| case SpvOpBitReverse: |
| case SpvOpBitCount: |
| return true; |
| default: |
| return false; |
| } |
| } |