diff --git a/renderdoc/driver/shaders/spirv/CMakeLists.txt b/renderdoc/driver/shaders/spirv/CMakeLists.txt index 701c2f04b..81e709179 100644 --- a/renderdoc/driver/shaders/spirv/CMakeLists.txt +++ b/renderdoc/driver/shaders/spirv/CMakeLists.txt @@ -93,6 +93,9 @@ set(sources spirv_common.h spirv_editor.cpp spirv_editor.h + spirv_gen.cpp + spirv_gen.h + spirv_op_helpers.h spirv_compile.cpp spirv_compile.h spirv_reflect.cpp diff --git a/renderdoc/driver/shaders/spirv/extinst.glsl.std.450.grammar.json b/renderdoc/driver/shaders/spirv/extinst.glsl.std.450.grammar.json new file mode 100644 index 000000000..3d9f39e76 --- /dev/null +++ b/renderdoc/driver/shaders/spirv/extinst.glsl.std.450.grammar.json @@ -0,0 +1,642 @@ +{ + "copyright" : [ + "Copyright (c) 2014-2016 The Khronos Group Inc.", + "", + "Permission is hereby granted, free of charge, to any person obtaining a copy", + "of this software and/or associated documentation files (the \"Materials\"),", + "to deal in the Materials without restriction, including without limitation", + "the rights to use, copy, modify, merge, publish, distribute, sublicense,", + "and/or sell copies of the Materials, and to permit persons to whom the", + "Materials are furnished to do so, subject to the following conditions:", + "", + "The above copyright notice and this permission notice shall be included in", + "all copies or substantial portions of the Materials.", + "", + "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS", + "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND", + "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ", + "", + "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS", + "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,", + "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL", + "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER", + "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING", + "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS", + "IN THE MATERIALS." + ], + "version" : 100, + "revision" : 2, + "instructions" : [ + { + "opname" : "Round", + "opcode" : 1, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "RoundEven", + "opcode" : 2, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Trunc", + "opcode" : 3, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "FAbs", + "opcode" : 4, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "SAbs", + "opcode" : 5, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "FSign", + "opcode" : 6, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "SSign", + "opcode" : 7, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Floor", + "opcode" : 8, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Ceil", + "opcode" : 9, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Fract", + "opcode" : 10, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Radians", + "opcode" : 11, + "operands" : [ + { "kind" : "IdRef", "name" : "'degrees'" } + ] + }, + { + "opname" : "Degrees", + "opcode" : 12, + "operands" : [ + { "kind" : "IdRef", "name" : "'radians'" } + ] + }, + { + "opname" : "Sin", + "opcode" : 13, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Cos", + "opcode" : 14, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Tan", + "opcode" : 15, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Asin", + "opcode" : 16, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Acos", + "opcode" : 17, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Atan", + "opcode" : 18, + "operands" : [ + { "kind" : "IdRef", "name" : "'y_over_x'" } + ] + }, + { + "opname" : "Sinh", + "opcode" : 19, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Cosh", + "opcode" : 20, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Tanh", + "opcode" : 21, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Asinh", + "opcode" : 22, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Acosh", + "opcode" : 23, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Atanh", + "opcode" : 24, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Atan2", + "opcode" : 25, + "operands" : [ + { "kind" : "IdRef", "name" : "'y'" }, + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Pow", + "opcode" : 26, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "Exp", + "opcode" : 27, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Log", + "opcode" : 28, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Exp2", + "opcode" : 29, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Log2", + "opcode" : 30, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Sqrt", + "opcode" : 31, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "InverseSqrt", + "opcode" : 32, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Determinant", + "opcode" : 33, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "MatrixInverse", + "opcode" : 34, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Modf", + "opcode" : 35, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'i'" } + ] + }, + { + "opname" : "ModfStruct", + "opcode" : 36, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "FMin", + "opcode" : 37, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "UMin", + "opcode" : 38, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "SMin", + "opcode" : 39, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "FMax", + "opcode" : 40, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "UMax", + "opcode" : 41, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "SMax", + "opcode" : 42, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "FClamp", + "opcode" : 43, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'minVal'" }, + { "kind" : "IdRef", "name" : "'maxVal'" } + ] + }, + { + "opname" : "UClamp", + "opcode" : 44, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'minVal'" }, + { "kind" : "IdRef", "name" : "'maxVal'" } + ] + }, + { + "opname" : "SClamp", + "opcode" : 45, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'minVal'" }, + { "kind" : "IdRef", "name" : "'maxVal'" } + ] + }, + { + "opname" : "FMix", + "opcode" : 46, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" }, + { "kind" : "IdRef", "name" : "'a'" } + ] + }, + { + "opname" : "IMix", + "opcode" : 47, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" }, + { "kind" : "IdRef", "name" : "'a'" } + ] + }, + { + "opname" : "Step", + "opcode" : 48, + "operands" : [ + { "kind" : "IdRef", "name" : "'edge'" }, + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "SmoothStep", + "opcode" : 49, + "operands" : [ + { "kind" : "IdRef", "name" : "'edge0'" }, + { "kind" : "IdRef", "name" : "'edge1'" }, + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Fma", + "opcode" : 50, + "operands" : [ + { "kind" : "IdRef", "name" : "'a'" }, + { "kind" : "IdRef", "name" : "'b'" }, + { "kind" : "IdRef", "name" : "'c'" } + ] + }, + { + "opname" : "Frexp", + "opcode" : 51, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'exp'" } + ] + }, + { + "opname" : "FrexpStruct", + "opcode" : 52, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Ldexp", + "opcode" : 53, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'exp'" } + ] + }, + { + "opname" : "PackSnorm4x8", + "opcode" : 54, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ] + }, + { + "opname" : "PackUnorm4x8", + "opcode" : 55, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ] + }, + { + "opname" : "PackSnorm2x16", + "opcode" : 56, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ] + }, + { + "opname" : "PackUnorm2x16", + "opcode" : 57, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ] + }, + { + "opname" : "PackHalf2x16", + "opcode" : 58, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ] + }, + { + "opname" : "PackDouble2x32", + "opcode" : 59, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ], + "capabilities" : [ "Float64" ] + }, + { + "opname" : "UnpackSnorm2x16", + "opcode" : 60, + "operands" : [ + { "kind" : "IdRef", "name" : "'p'" } + ] + }, + { + "opname" : "UnpackUnorm2x16", + "opcode" : 61, + "operands" : [ + { "kind" : "IdRef", "name" : "'p'" } + ] + }, + { + "opname" : "UnpackHalf2x16", + "opcode" : 62, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ] + }, + { + "opname" : "UnpackSnorm4x8", + "opcode" : 63, + "operands" : [ + { "kind" : "IdRef", "name" : "'p'" } + ] + }, + { + "opname" : "UnpackUnorm4x8", + "opcode" : 64, + "operands" : [ + { "kind" : "IdRef", "name" : "'p'" } + ] + }, + { + "opname" : "UnpackDouble2x32", + "opcode" : 65, + "operands" : [ + { "kind" : "IdRef", "name" : "'v'" } + ], + "capabilities" : [ "Float64" ] + }, + { + "opname" : "Length", + "opcode" : 66, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "Distance", + "opcode" : 67, + "operands" : [ + { "kind" : "IdRef", "name" : "'p0'" }, + { "kind" : "IdRef", "name" : "'p1'" } + ] + }, + { + "opname" : "Cross", + "opcode" : 68, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "Normalize", + "opcode" : 69, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "FaceForward", + "opcode" : 70, + "operands" : [ + { "kind" : "IdRef", "name" : "'N'" }, + { "kind" : "IdRef", "name" : "'I'" }, + { "kind" : "IdRef", "name" : "'Nref'" } + ] + }, + { + "opname" : "Reflect", + "opcode" : 71, + "operands" : [ + { "kind" : "IdRef", "name" : "'I'" }, + { "kind" : "IdRef", "name" : "'N'" } + ] + }, + { + "opname" : "Refract", + "opcode" : 72, + "operands" : [ + { "kind" : "IdRef", "name" : "'I'" }, + { "kind" : "IdRef", "name" : "'N'" }, + { "kind" : "IdRef", "name" : "'eta'" } + ] + }, + { + "opname" : "FindILsb", + "opcode" : 73, + "operands" : [ + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "FindSMsb", + "opcode" : 74, + "operands" : [ + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "FindUMsb", + "opcode" : 75, + "operands" : [ + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "InterpolateAtCentroid", + "opcode" : 76, + "operands" : [ + { "kind" : "IdRef", "name" : "'interpolant'" } + ], + "capabilities" : [ "InterpolationFunction" ] + }, + { + "opname" : "InterpolateAtSample", + "opcode" : 77, + "operands" : [ + { "kind" : "IdRef", "name" : "'interpolant'" }, + { "kind" : "IdRef", "name" : "'sample'" } + ], + "capabilities" : [ "InterpolationFunction" ] + }, + { + "opname" : "InterpolateAtOffset", + "opcode" : 78, + "operands" : [ + { "kind" : "IdRef", "name" : "'interpolant'" }, + { "kind" : "IdRef", "name" : "'offset'" } + ], + "capabilities" : [ "InterpolationFunction" ] + }, + { + "opname" : "NMin", + "opcode" : 79, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "NMax", + "opcode" : 80, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ] + }, + { + "opname" : "NClamp", + "opcode" : 81, + "operands" : [ + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'minVal'" }, + { "kind" : "IdRef", "name" : "'maxVal'" } + ] + } + ] +} diff --git a/renderdoc/driver/shaders/spirv/gen_spirv_code.py b/renderdoc/driver/shaders/spirv/gen_spirv_code.py new file mode 100644 index 000000000..e79cd4be9 --- /dev/null +++ b/renderdoc/driver/shaders/spirv/gen_spirv_code.py @@ -0,0 +1,1316 @@ +#!/usr/bin/env python3 + +import os +import io +import sys +import re +import argparse +import json +import xml.etree.ElementTree as ET + +# on msys, use crlf output +nl = None +if sys.platform == 'msys': + nl = "\r\n" + +# Get the file, relative to this script's location (same directory) +# that way we're not sensitive to CWD +pathname = os.path.abspath(os.path.dirname(sys.argv[0])) + os.path.sep + +with open(pathname + 'spirv.core.grammar.json', mode='r') as f: + spirv = json.load(f) + +with open(pathname + 'extinst.glsl.std.450.grammar.json', mode='r') as f: + glsl450 = json.load(f) + +# open XML registry +registry = ET.parse(pathname + 'spir-v.xml').getroot() + +# open the file for write +header = open(pathname + 'spirv_gen.h', mode='w', newline = nl) +ops_header = open(pathname + 'spirv_op_helpers.h', mode='w', newline = nl) +cpp = open(pathname + 'spirv_gen.cpp', mode='w', newline = nl) + +############################################################################### +## +## Headers +## +############################################################################### + +def prefix_star(line): + if line == '': + return ' *' + else: + return ' * ' + line + +def operand_name(name, lowercase_first = True): + name = name.replace('\n', ' ') + # special case a few very awkward names + if re.search(r'member [0-9].*\.\.\.', name, re.RegexFlag.I): + return 'members' + if re.search(r'parameter [0-9].*\.\.\.', name, re.RegexFlag.I): + return 'parameters' + if re.search(r'argument [0-9].*\.\.\.', name, re.RegexFlag.I): + return 'arguments' + if re.search(r'variable, parent.*\.\.\.', name, re.RegexFlag.I): + return 'parents' + + name = re.sub(r'<<(.*),(.*)>>', r'\2', name) + name = re.sub(r'[ \'~<>./-]', '', name) + + if name.lower() == 'interface': + return 'iface' + + if name.lower() == 'default': + return 'def' + + if lowercase_first: + return name[0].lower() + name[1:] + else: + return name + +copyright = ''' +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2019 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +/****************************************************************************** + * Generated from Khronos SPIR-V machine-readable JSON grammar. + * +{} + ******************************************************************************/ +'''.format("\n".join([prefix_star(line.strip()) for line in spirv['copyright']])).strip() + +header.write('''{copyright} + +#pragma once + +// This file is autogenerated with gen_spirv_code.py - any changes will be overwritten next time +// that script is run. +// $ ./gen_spirv_code.py + +// We need to disable clang-format since this file is programmatically generated +// clang-format off + +#include +#include "api/replay/renderdoc_replay.h" + +#undef None +#undef CopyMemory +#undef MemoryBarrier + +namespace rdcspv +{{ +static const uint32_t MagicNumber = {magic}; +static const uint32_t VersionMajor = {major}; +static const uint32_t VersionMinor = {minor}; +static const uint32_t VersionRevision = {revision}; +static const uint32_t VersionPacked = ({major} << 16) | ({minor} << 8); +static const uint32_t OpCodeMask = 0xffff; +static const uint32_t WordCountShift = 16; +static const uint32_t FirstRealWord = 5; + +struct Id +{{ + constexpr inline Id() : id(0) {{}} + // only allow explicit functions to cast to/from uint32_t + constexpr static inline Id fromWord(uint32_t i) {{ return Id(i); }} + inline uint32_t value() const {{ return id; }} + constexpr inline explicit operator bool() const {{ return id != 0; }} + constexpr inline bool operator==(const Id o) const {{ return id == o.id; }} + constexpr inline bool operator!=(const Id o) const {{ return id != o.id; }} + constexpr inline bool operator<(const Id o) const {{ return id < o.id; }} + constexpr inline bool operator==(const uint32_t o) const {{ return id == o; }} + constexpr inline bool operator!=(const uint32_t o) const {{ return id != o; }} + constexpr inline bool operator<(const uint32_t o) const {{ return id < o; }} +private: + constexpr inline Id(uint32_t i) : id(i) {{}} + uint32_t id; +}}; + +enum class Generator : uint32_t +{{'''.format(copyright = copyright, magic = spirv['magic_number'], major = spirv['major_version'], minor = spirv['minor_version'], revision = spirv['revision'])) + +generator_tostr = '' + +for gen in registry.findall('ids[@type=\'vendor\']/id[@tool]'): + name = operand_name(gen.attrib['tool'], lowercase_first=False) + + tostr = '{} from {} - {}'.format(gen.attrib['tool'], gen.attrib['vendor'], gen.attrib['comment']) + + generator_tostr += ' STRINGISE_ENUM_CLASS_NAMED({}, "{}");\n'.format(name, tostr.replace('"', '\\"').replace('\\', '\\\\')) + header.write('\n {} = {},'.format(name, gen.attrib['value'])) + +header.write('\n};\n\n') + +ops_header.write('''{copyright} + +#pragma once + +// This file is autogenerated with gen_spirv_code.py - any changes will be overwritten next time +// that script is run. +// $ ./gen_spirv_code.py + +// We need to disable clang-format since this file is programmatically generated +// clang-format off + +#include +#include +#include "api/replay/renderdoc_replay.h" + +#undef None +#undef CopyMemory +#undef MemoryBarrier + +#include "spirv_common.h" +#include "spirv_gen.h" + +namespace rdcspv +{{ + +template +Type DecodeParam(const ConstIter &it, uint32_t &word); + +template<> +inline uint32_t DecodeParam(const ConstIter &it, uint32_t &word) +{{ + if(word >= it.size()) return 0; + + uint32_t ret = it.word(word); + word += 1; + return ret; +}} + +template<> +inline Id DecodeParam(const ConstIter &it, uint32_t &word) +{{ + if(word >= it.size()) return Id(); + + Id ret = Id::fromWord(it.word(word)); + word += 1; + return ret; +}} + +template<> +inline rdcstr DecodeParam(const ConstIter &it, uint32_t &word) +{{ + if(word >= it.size()) return ""; + + rdcstr ret = (const char *)&it.word(word); + word += uint32_t(ret.size() / 4) + 1; + return ret; +}} + +template +rdcarray MultiParam(const ConstIter &it, uint32_t &word) +{{ + rdcarray ret; + while(word < it.size()) + {{ + Type t = DecodeParam(it, word); + ret.push_back(t); + }} + return ret; +}} + +inline void EncodeParam(std::vector &words, const rdcstr &str) +{{ + size_t i=0, remainingChars = str.size() + 1; + while(remainingChars > 0) + {{ + uint32_t word = 0; + for(size_t w=0; w < remainingChars && w < 4; w++) + word |= uint32_t(str[i+w]) << (w*8); + words.push_back(word); + + i += 4; + if(remainingChars < 4) + remainingChars = 0; + else + remainingChars -= 4; + }} +}} + +'''.format(copyright = copyright)) + +cpp.write('''{copyright} + +// This file is autogenerated with gen_spirv_code.py - any changes will be overwritten next time +// that script is run. +// $ ./gen_spirv_code.py + +// We need to disable clang-format since this file is programmatically generated +// clang-format off + +#include "spirv_gen.h" +#include "os/os_specific.h" +#include "spirv_op_helpers.h" + +'''.format(copyright = copyright)) + +############################################################################### +## +## Operands (declare enums, stringise, preprocess) +## +############################################################################### + +positional_names = [ 'first', 'second', 'third' ] +kinds = {} + +for operand_kind in spirv['operand_kinds']: + name = operand_kind['kind'] + + if 'enumerants' in operand_kind: + operand_kind['has_params'] = any(['parameters' in value for value in operand_kind['enumerants']]) + else: + operand_kind['has_params'] = False + + kinds[name] = operand_kind + + operand_kind['push_words'] = lambda name: 'words.push_back((uint32_t){});'.format(name) + operand_kind['from_words'] = None + operand_kind['is_id'] = False + + if operand_kind['category'] == 'ValueEnum': + operand_kind['size'] = 1 + operand_kind['def_name'] = name[0].lower() + name[1:] + operand_kind['def_value'] = name + '::Invalid' + operand_kind['type'] = name + + decl = '' + stringise = '' + + used = [] + + for value in operand_kind['enumerants']: + value_name = value['enumerant'] + if value_name[0].isdigit(): + value_name = '_' + value_name + decl += ' {} = {},\n'.format(value_name, value['value']) + + if value['value'] in used: + continue + + used.append(value['value']) + + if value_name != value['enumerant']: + stringise += ' STRINGISE_ENUM_CLASS_NAMED({}, "{}");\n'.format(value_name, value['enumerant']) + else: + stringise += ' STRINGISE_ENUM_CLASS({});\n'.format(value_name) + + header.write('''enum class {name} : uint32_t +{{ +{values} + Max, + Invalid = ~0U, +}}; + +'''.format(name = name, values = decl.rstrip())) + + cpp.write('''template <> +rdcstr DoStringise(const rdcspv::{name} &el) +{{ + BEGIN_ENUM_STRINGISE(rdcspv::{name}); + {{ +{values} + }} + END_ENUM_STRINGISE(); +}} + +'''.format(name = name, values = stringise.rstrip())) + elif operand_kind['category'] == 'BitEnum': + operand_kind['size'] = 1 + operand_kind['def_name'] = name[0].lower() + name[1:] + operand_kind['def_value'] = name + '::None' + operand_kind['type'] = name + + used = [] + + decl = '' + stringise = '' + for value in operand_kind['enumerants']: + decl += ' {} = {},\n'.format(value['enumerant'], value['value']) + + if value['value'] in used: + continue + + used.append(value['value']) + + if value['enumerant'] == 'None': + stringise += ' STRINGISE_BITFIELD_CLASS_VALUE(None);\n\n' + else: + stringise += ' STRINGISE_BITFIELD_CLASS_BIT({});\n'.format(value['enumerant']) + + header.write('''enum class {name} : uint32_t +{{ +{values} + Max, + Invalid = ~0U, +}}; + +BITMASK_OPERATORS({name}); + +'''.format(name = name, values = decl.rstrip())) + + cpp.write('''template <> +rdcstr DoStringise(const rdcspv::{name} &el) +{{ + BEGIN_BITFIELD_STRINGISE(rdcspv::{name}); + {{ +{values} + }} + END_BITFIELD_STRINGISE(); +}} + +'''.format(name = name, values = stringise.rstrip())) + # Hardcoded special types that we hardcode behaviour for + elif (operand_kind['kind'] == 'IdRef'): + operand_kind['size'] = 1 + operand_kind['def_name'] = 'id' + operand_kind['def_value'] = 'Id()' + operand_kind['type'] = 'Id' + operand_kind['is_id'] = True + operand_kind['push_words'] = lambda name: 'words.push_back({}.value());'.format(name) + operand_kind['from_words'] = lambda name: 'Id::fromWord({})'.format(name) + elif (operand_kind['kind'] == 'IdResultType' or + operand_kind['kind'] == 'IdResult' or + operand_kind['kind'] == 'IdMemorySemantics' or + operand_kind['kind'] == 'IdScope'): + operand_kind['size'] = 1 + operand_kind['type'] = name + operand_kind['is_id'] = True + operand_kind['def_name'] = name[2].lower() + name[3:] + operand_kind['def_value'] = name + '()' + operand_kind['push_words'] = lambda name: 'words.push_back({}.value());'.format(name) + operand_kind['from_words'] = lambda name: 'Id::fromWord({})'.format(name) + header.write('using {} = Id;\n\n'.format(name)) + # For simplicity, assume literal integers are 32-bit in size + elif (operand_kind['kind'] == 'LiteralInteger'): + operand_kind['size'] = 1 + operand_kind['def_name'] = 'num' + operand_kind['def_value'] = '0' + operand_kind['type'] = 'uint32_t' + elif (operand_kind['kind'] == 'LiteralString'): + operand_kind['size'] = -1000000 + operand_kind['type'] = 'rdcstr' + operand_kind['def_name'] = 'str' + operand_kind['def_value'] = '""' + operand_kind['push_words'] = lambda name: 'EncodeParam(words, {});'.format(name) + operand_kind['from_words'] = lambda name: 'DecodeParam({})'.format(name) + elif (operand_kind['kind'] == 'LiteralContextDependentNumber' or + operand_kind['kind'] == 'LiteralExtInstInteger' or + operand_kind['kind'] == 'LiteralSpecConstantOpInteger'): + operand_kind['size'] = None + elif (operand_kind['kind'] == 'PairLiteralIntegerIdRef'): + operand_kind['size'] = 2 + operand_kind['def_name'] = name[0].lower() + name[1:] + operand_kind['def_value'] = '{0, Id()}' + operand_kind['type'] = name + operand_kind['push_words'] = lambda name: 'words.push_back((uint32_t){0}.first); words.push_back({0}.second.value());'.format(name) + ops_header.write('struct {} {{ uint32_t first; Id second; }};\n\n'.format(name)) + elif (operand_kind['kind'] == 'PairIdRefLiteralInteger'): + operand_kind['size'] = 2 + operand_kind['def_name'] = name[0].lower() + name[1:] + operand_kind['def_value'] = '{Id(), 0}' + operand_kind['type'] = name + operand_kind['push_words'] = lambda name: 'words.push_back({0}.first.value()); words.push_back((uint32_t){0}.second);'.format(name) + ops_header.write('struct {} {{ Id first; uint32_t second; }};\n\n'.format(name)) + elif (operand_kind['kind'] == 'PairIdRefIdRef'): + operand_kind['size'] = 2 + operand_kind['def_name'] = name[0].lower() + name[1:] + operand_kind['def_value'] = '{Id(), Id()}' + operand_kind['type'] = name + operand_kind['push_words'] = lambda name: 'words.push_back({0}.first.value()); words.push_back({0}.second.value());'.format(name) + ops_header.write('struct {} {{ Id first, second; }};\n\n'.format(name)) + continue + else: + raise TypeError("Unexpected operand {} of type {}".format(operand_kind['kind'], operand_kind['category'])) + + if operand_kind['from_words'] is None: + operand_kind['from_words'] = lambda name,kind=operand_kind: '({}){}'.format(kind['type'], name) + +ops_header.write(''' +template<> +inline PairIdRefIdRef DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return {}; + + PairIdRefIdRef ret = { Id::fromWord(it.word(word)), Id::fromWord(it.word(word+1)) }; + word += 2; + return ret; +} + +template<> +inline PairLiteralIntegerIdRef DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return {}; + + PairLiteralIntegerIdRef ret = { it.word(word), Id::fromWord(it.word(word+1)) }; + word += 2; + return ret; +} + +template<> +inline PairIdRefLiteralInteger DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return {}; + + PairIdRefLiteralInteger ret = { Id::fromWord(it.word(word)), it.word(word+1) }; + word += 2; + return ret; +} +''') + +tostrs = '' +tostr_decls = '' + +# Second pass to declare operand parameter structs in ops helper header +for operand_kind in spirv['operand_kinds']: + name = operand_kind['kind'] + + if not operand_kind['has_params']: + if operand_kind['category'] == 'ValueEnum': + ops_header.write('inline uint16_t OptionalWordCount(const {0} val) {{ return val != {0}::Invalid ? 1 : 0; }}\n\n'.format(name)) + continue + + values = '' + set_unset = '' + word_count_cases = '' + decode_cases = '' + encode_cases = '' + constructors = '' + tostr_cases = '' + + value_enum = operand_kind['category'] == 'ValueEnum' + bit_enum = operand_kind['category'] == 'BitEnum' + + used = [] + + for value in operand_kind['enumerants']: + params = '' + assign = '' + ret_assign = '' + + new_value = value['value'] not in used + used.append(value['value']) + + if new_value and bit_enum: + tostr_cases += ' if(el.flags & {0}::{1})\n ret += "{1}"'.format(name, value['enumerant']) + + if 'parameters' in value: + # We want plain unions, so don't include strings + if any([param['kind'] == 'LiteralString' for param in value['parameters']]): + continue + + if new_value and value_enum: + tostr_cases += ' case {0}::{1}:\n ret += '.format(name, value['enumerant']) + + member = "" + param_name = operand_name(value['enumerant']) + size = 0 + + if new_value: + if value_enum: + decode_cases += ' case {0}::{1}:\n'.format(name, value['enumerant']) + encode_cases += ' case {0}::{1}:\n'.format(name, value['enumerant']) + else: + decode_cases += ' if(ret.flags & {0}::{1})\n {{\n'.format(name, value['enumerant']) + encode_cases += ' if(param.flags & {0}::{1})\n {{\n'.format(name, value['enumerant']) + + # if we only have one parameter, add its type to the set + if len(value['parameters']) == 1: + param = value['parameters'][0] + size += kinds[param['kind']]['size'] + param_type = kinds[param['kind']]['type'] + member = "{} {};\n".format(param_type, param_name) + + if value_enum: + values += ' ' + if new_value: + decode_cases += ' ' + encode_cases += ' ' + + values += " " + member + params += "{} {}Param".format(param_type, param_name) + assign += " {0} = {0}Param;".format(param_name) + ret_assign += " ret.{0} = {0};\n".format(param_name) + + if new_value: + decode_cases += ' ret.{} = {};\n'.format(param_name, kinds[param['kind']]['from_words']('it.word(word)')) + encode_cases += ' {}\n'.format(kinds[param['kind']]['push_words']('param.{}'.format(param_name))) + if kinds[param['kind']]['is_id']: + tostr_cases += ' "(" + idName(el.{}) + ")"'.format(param_name) + else: + tostr_cases += ' "(" + ToStr(el.{}) + ")"'.format(param_name) + + # if we have multiple we need a separate struct for this thing + else: + struct_name = param_name[0].upper() + param_name[1:] + 'Params' + member = "{} {};\n".format(struct_name, param_name) + if value_enum: + values += ' ' + values += " " + member + + struct_values = '' + + if new_value: + tostr_cases += ' "("' + + for i,param in enumerate(value['parameters']): + subparam_name = positional_names[i] + kind = kinds[param['kind']] + size += kind['size'] + if 'name' in param: + subparam_name = operand_name(param['name']) + struct_values += " {} {};\n".format(kind['type'], subparam_name) + + if new_value: + if value_enum: + decode_cases += ' ' + encode_cases += ' ' + decode_cases += ' ret.{}.{} = {};\n'.format(param_name, subparam_name, kinds[param['kind']]['from_words']('it.word(word+{})'.format(i))) + encode_cases += ' {}\n'.format(kinds[param['kind']]['push_words']('param.{}.{}'.format(param_name, subparam_name))) + if kinds[param['kind']]['is_id']: + tostr_cases += ' + idName(el.{}.{}) + '.format(param_name, subparam_name) + else: + tostr_cases += ' + ToStr(el.{}.{}) + '.format(param_name, subparam_name) + + assign += " {0}.{1} = {1};".format(param_name, subparam_name) + ret_assign += " ret.{0}.{1} = {0}.{1};\n".format(param_name, subparam_name) + params += "{} {}".format(kind['type'], subparam_name) + if i != len(value['parameters'])-1: + params += ", " + tostr_cases += '", " ' + + if new_value: + tostr_cases += '")"' + + header.write('''struct {struct_name} +{{ +{struct_values} +}}; + +'''.format(struct_name = struct_name, struct_values = struct_values.rstrip())) + + if new_value: + if value_enum: + decode_cases += ' word += {};\n'.format(size) + decode_cases += ' break;\n' + encode_cases += ' break;\n' + tostr_cases += '; break;\n' + else: + decode_cases += ' word += {};\n'.format(size) + decode_cases += ' }\n' + encode_cases += ' }\n' + word_count_cases += ' case {}::{}: return {};\n'.format(name, value['enumerant'], size) + + constructors += '''template<>\nstruct {name}Param<{name}::{value}> +{{ + {member} + {name}Param({params}) {{ {assign} }} + operator {name}AndParamData() + {{ + {name}AndParamData ret({name}::{value}); +{ret_assign} + return ret; + }} +}}; + +'''.format(value=value['enumerant'], member=member.rstrip(), name=name, params=params, assign=assign, ret_assign=ret_assign.rstrip()) + + if new_value and bit_enum: + tostr_cases += ' ", ";\n' + + + set_unset += ''' void set{flag}({params}) {{ flags |= {name}::{flag};{assign} }} + void unset{flag}() {{ flags &= ~{name}::{flag}; }} +'''.format(flag=value['enumerant'], name=name, params=params, assign=assign) + + if constructors != '': + constructors = 'template<{name} val> struct {name}Param;\n\n'.format(name=name) + constructors + + # ValueEnums are set up as one or many pairs of enum/params, enum/params, etc. So we declare a struct for the pair + # and declare an array if the op wants many + if value_enum: + tostrs += '''template<> +std::string ParamToStr(const std::function &idName, const rdcspv::{name}AndParamData &el) +{{ + rdcstr ret = ToStr(el.value); + + switch(el.value) + {{ +{tostr_cases} + default: + break; + }} + + return ret; +}} + +'''.format(name=name, tostr_cases=tostr_cases.rstrip()) + + tostr_decls += '''template<> +std::string ParamToStr(const std::function &idName, const rdcspv::{name}AndParamData &el);'''.format(name=name) + + header.write('''struct {name}AndParamData +{{ + {name}AndParamData({name} v = {name}::Invalid) : value(v) {{}} + {name} value; + union + {{ +{values} + }}; + + operator {name}() const {{ return value; }} + bool operator ==(const {name} v) const {{ return value == v; }} +}}; + +'''.format(name=name, values=values.rstrip())) + + ops_header.write('''{constructors} + +template<> +inline {name}AndParamData DecodeParam(const ConstIter &it, uint32_t &word) +{{ + if(word >= it.size()) return {name}AndParamData(); + + {name}AndParamData ret(({name})it.word(word)); + word++; + switch(ret.value) + {{ +{decode_cases} + default: break; + }} + return ret; +}} + +inline void EncodeParam(std::vector &words, const {name}AndParamData ¶m) +{{ + words.push_back((uint32_t)param.value); + switch(param.value) + {{ +{encode_cases} + default: break; + }} +}} + +'''.format(name=name, value_name=operand_name(name), decode_cases=decode_cases.rstrip(), + constructors=constructors, encode_cases=encode_cases.rstrip())) + operand_kind['type'] = '{}AndParamData'.format(name) + # BitEnums are set up with one bitmask, and then a series of parameters, so we declare a struct with an array + elif bit_enum: + tostrs += '''template<> +std::string ParamToStr(const std::function &idName, const rdcspv::{name}AndParamDatas &el) +{{ + rdcstr ret; + +{tostr_cases} + + // remove trailing ", " + if(ret.size() > 2) + ret.erase(ret.size()-2, 2); + + return ret; +}} + +'''.format(name=name, tostr_cases=tostr_cases.rstrip()) + + tostr_decls += '''template<> +std::string ParamToStr(const std::function &idName, const rdcspv::{name}AndParamDatas &el);'''.format(name=name) + + header.write('''struct {name}AndParamDatas +{{ + {name}AndParamDatas({name} f = {name}::None) : flags(f) {{}} + {name} flags; +{values} + + operator {name}() const {{ return flags; }} + bool operator &(const {name} v) const {{ return bool(flags & v); }} +{set_unset} +}}; + +'''.format(name=name, values=values.rstrip(), set_unset=set_unset.rstrip())) + + ops_header.write('''template<> +inline {name}AndParamDatas DecodeParam(const ConstIter &it, uint32_t &word) +{{ + if(word >= it.size()) return {name}AndParamDatas(); + + {name}AndParamDatas ret(({name})it.word(word)); + word++; +{decode_cases} + return ret; +}} + +inline void EncodeParam(std::vector &words, const {name}AndParamDatas ¶m) +{{ + words.push_back((uint32_t)param.flags); +{encode_cases} +}} + +'''.format(name=name, decode_cases=decode_cases.rstrip(), encode_cases=encode_cases.rstrip())) + operand_kind['type'] = '{}AndParamDatas'.format(name) + else: + raise TypeError("unexpected operand kind {} with parameters".format(operand_kind['category'])) + + ops_header.write('''inline uint16_t ExtraWordCount(const {name} {value_name}) +{{ + switch({value_name}) + {{ +{word_count_cases} + default: break; + }} + return 0; +}} + +'''.format(name = name, value_name = operand_name(name), word_count_cases = word_count_cases.rstrip())) + +ops_header.write(''' +inline uint16_t ExtraWordCount(const rdcstr &val) +{ + return uint16_t(val.size() / 4); +} + +inline uint16_t OptionalWordCount(const rdcstr &val) +{ + if(val.empty()) return 0; + return uint16_t(val.size() / 4) + 1; +} + +inline uint16_t OptionalWordCount(const Id &val) +{ + return val != Id() ? 1 : 0; +} + +inline uint16_t OptionalWordCount(const PairIdRefLiteralInteger &val) +{ + return val.first != Id() ? 2 : 0; +} + +inline uint16_t OptionalWordCount(const PairLiteralIntegerIdRef &val) +{ + return val.second != Id() ? 2 : 0; +} + +inline uint16_t OptionalWordCount(const PairIdRefIdRef &val) +{ + return val.first != Id() ? 2 : 0; +} + +template +uint16_t MultiWordCount(const rdcarray &multiParams) +{ + uint16_t ret = 0; + for(size_t i=0; i < multiParams.size(); i++) + ret += sizeof(multiParams[i])/sizeof(uint32_t); + return ret; +} +''') + +############################################################################### +## +## Opcodes (declare enum / stringise) +## +############################################################################### + +# Quickly preprocess, find parameters with duplicated names and disambiguate +for inst in spirv['instructions']: + if 'operands' in inst: + operands = inst['operands'] + + duplicates = [] + + for i,A in enumerate(operands): + for j,B in enumerate(operands): + if j <= i: + continue + + a = operand_name(A['name'] if 'name' in A else kinds[A['kind']]['def_name']) + b = operand_name(B['name'] if 'name' in B else kinds[B['kind']]['def_name']) + + if a == b: + if i not in duplicates: + duplicates.append(i) + if j not in duplicates: + duplicates.append(j) + + if len(duplicates) > 0: + for idx,arg in enumerate(duplicates): + A = operands[arg] + operands[arg]['name'] = operand_name(A['name'] if 'name' in A else kinds[A['kind']]['def_name']) + str(idx) + +used = [] +decl = '' +stringise = '' +op_structs = '' +op_decoder = '' +used_ids = '' +disassemble = '' + +for inst in spirv['instructions']: + decl += ' {} = {},\n'.format(inst['opname'][2:], inst['opcode']) + + if inst['opcode'] in used: + continue + + stringise += ' STRINGISE_ENUM_CLASS({});\n'.format(inst['opname'][2:]) + + result = -1 + resultType = -1 + + used_ids += ' case rdcspv::Op::{}:\n'.format(inst['opname'][2:]) + + operands = [] + + if 'operands' in inst: + operands = inst['operands'] + last_operand = operands[-1] + + for i,operand in enumerate(operands): + if operand['kind'] == 'IdResult': + result = i+1 + if operand['kind'] == 'IdResultType': + resultType = i+1 + + disassemble += ' case rdcspv::Op::{}:\n'.format(inst['opname'][2:]) + disassemble += ' {\n' + + if any([kinds[operand['kind']]['size'] is None for operand in operands]): + op_struct = 'struct {}; // has operands with variable sizes\n\n'.format(inst['opname']) + + disassemble += ' OpDecoder decoded(it);\n'.format(inst['opname'][2:]) + + if resultType > 0 and result > 0: + disassemble += ' ret += declName(decoded.resultType, decoded.result) + " = ";\n' + elif resultType > 0 and result == -1: + raise ValueError("Unexpected result type without result") + elif resultType == -1 and result > 0: + disassemble += ' ret += idName(decoded.result) + " = ";\n' + + disassemble += ' ret += "{}(...)";\n'.format(inst['opname'][2:]) + disassemble += ' break;\n' + disassemble += ' }\n' + else: + params = '' + assign = '' + member_decl = '' + size_name = 'FixedWordSize' + construct_size = 'FixedWordSize' + size = 1 # opcode / wordcount packed + all_size = 1 # size, but with all optionals included + iter_init = ' memcpy(this, &(*it), sizeof(*this));' + complex_type = False + manual_init = ' this->op = OpCode;\n' + manual_init += ' this->wordCount = (uint16_t)it.size();\n' + oper_cast = ' operator Operation() const\n {\n std::vector words;\n' + has_funcs = '' + + disassemble += ' Op{} decoded(it);\n'.format(inst['opname'][2:]) + + if resultType > 0 and result > 0: + disassemble += ' ret += declName(decoded.resultType, decoded.result) + " = ";\n' + elif resultType > 0 and result == -1: + raise ValueError("Unexpected result type without result") + elif resultType == -1 and result > 0: + disassemble += ' ret += idName(decoded.result) + " = ";\n' + + disassemble += ' ret += "{}("'.format(inst['opname'][2:]) + + disassemble_params = False + + if 'operands' in inst: + for i,operand in enumerate(operands): + kind = kinds[operand['kind']] + + if kind['has_params'] and not complex_type: + size_name = 'MinWordSize' + construct_size = 'MinWordSize' + complex_type = True + manual_init += ' uint32_t word = {};\n'.format(all_size) + + if kind['is_id']: + used_ids += ' usedids.insert(Id::fromWord(it.word({})));\n'.format(all_size) + + quantifier = '' + + if 'quantifier' in operand: + quantifier = operand['quantifier'] + if not complex_type: + size_name = 'MinWordSize' + construct_size = 'MinWordSize' + complex_type = True + if quantifier == '*': + manual_init += ' uint32_t word = {};\n'.format(all_size) + + if kind['size'] < 0: + size_name = 'MinWordSize' + construct_size = 'MinWordSize' + complex_type = True + manual_init += ' uint32_t word = {};\n'.format(all_size) + + opType,opName = (kind['type'], operand_name(operand['name'] if 'name' in operand else kind['def_name'])) + + if i+1 != resultType and i+1 != result: + if quantifier == '*': + disassemble += ' + ParamsToStr(idName, decoded.{})'.format(opName) + else: + if opType == 'IdScope': + disassemble += ' + ToStr(Scope(constIntVal(decoded.{})))'.format(opName) + elif opType == 'IdMemorySemantics': + disassemble += ' + ToStr(MemorySemantics(constIntVal(decoded.{})))'.format(opName) + else: + disassemble += ' + ParamToStr(idName, decoded.{})'.format(opName) + + if i+1 < len(operands): + disassemble += ' + ", "' + + disassemble_params = True + + if quantifier == '?': + params += '{} {} = {}, '.format(opType, opName, kind['def_value']) + elif quantifier == '*': + params += 'const rdcarray<{}> &{} = {{}}, '.format(opType, opName) + else: + params += '{} {}, '.format(opType, opName) + + if quantifier == '*': + member_decl += ' rdcarray<{}> {};\n'.format(opType, opName) + else: + member_decl += ' {} {};\n'.format(opType, opName) + assign += ' this->{} = {};\n'.format(opName, opName) + + if operand['kind'] == 'LiteralString': + if quantifier == '*': + raise ValueError('operand {} in {} is string but has * quantifier'.format(opName, inst['opname'])) + manual_init += ' this->{name} = DecodeParam<{type}>(it, word);\n'.format(name = opName, type = opType) + oper_cast += ' EncodeParam(words, {name});\n'.format(name = opName) + if quantifier == '?': + construct_size += ' + OptionalWordCount({})'.format(opName) + has_funcs += ' bool Has{name}() const {{ return wordCount > {idx}; }}\n'.format(idx = all_size, name = opName[0].upper() + opName[1:]) + else: + construct_size += ' + ExtraWordCount({})'.format(opName) + + elif kind['has_params']: + if quantifier == '*': + raise ValueError('operand {} in {} has * quantifier and params'.format(opName, inst['opname'])) + manual_init += ' this->{name} = DecodeParam<{type}>(it, word);\n'.format(name = opName, type = opType) + oper_cast += ' EncodeParam(words, {name});\n'.format(name = opName) + construct_size += ' + ExtraWordCount({})'.format(opName) + elif quantifier == '*': + manual_init += ' this->{name} = MultiParam<{type}>(it, word);\n'.format(name = opName, type = opType) + construct_size += ' + MultiWordCount({})'.format(opName) + oper_cast += ' for(size_t i=0; i < {name}.size(); i++)\n'.format(name = opName) + oper_cast += ' {\n' + oper_cast += ' {push_words}\n'.format(push_words = kind['push_words']('{}[i]'.format(opName))) + oper_cast += ' }\n' + elif quantifier == '?': + manual_init += ' this->{name} = (it.size() > {idx}) ? {value} : {def_value};\n'.format(name = opName, type = opType, idx = all_size, value = kind['from_words']('it.word({})'.format(all_size)), def_value=kind['def_value']) + construct_size += ' + OptionalWordCount({})'.format(opName) + oper_cast += ' if({name} != {def_value}) {push_words}\n'.format(name = opName, def_value=kind['def_value'], push_words = kind['push_words'](opName)) + has_funcs += ' bool Has{name}() const {{ return wordCount > {idx}; }}\n'.format(idx = all_size, name = opName[0].upper() + opName[1:]) + else: + manual_init += ' this->{name} = {value};\n'.format(name = opName, type = opType, value = kind['from_words']('it.word({})'.format(all_size))) + oper_cast += ' {push_words}\n'.format(push_words = kind['push_words'](opName)) + + if kind['size'] >= 0: + all_size += kind['size'] + else: + all_size += 1 + + if quantifier == '': + size = all_size + else: + assign = ' // no operands' + member_decl = ' // no operands' + + if complex_type: + iter_init = manual_init.rstrip() + oper_cast += ' return Operation(OpCode, words);\n }\n' + else: + oper_cast = '' + + if params != '': + params = params[0:-2] + + if disassemble_params: + disassemble += ' + ")";\n' + else: + disassemble += ' ")";\n' + disassemble += ' break;\n' + disassemble += ' }\n' + + if has_funcs != '': + has_funcs = '\n\n' + has_funcs + + op_struct = '''struct {name} +{{ + {name}(const ConstIter &it) + {{ +{iter_init} + }} + {name}({params}) + : op(Op::{opname}) + , wordCount({construct_size}) + {{ +{assign} + }} +{oper_cast} + static constexpr Op OpCode = Op::{opname}; + static constexpr uint16_t {size_name} = {size}U; + Op op; + uint16_t wordCount; +{member_decl}{has_funcs} +}}; + +'''.format(opname=inst['opname'][2:], name=inst['opname'], params=params, iter_init=iter_init, assign=assign.rstrip(), + member_decl=member_decl.rstrip(), size_name=size_name, construct_size=construct_size, + oper_cast=oper_cast, size=size, has_funcs=has_funcs.rstrip()) + + + op_structs += op_struct + + # Sanity check that quantifiers only happen on final operands. Also if there are multiple they are all ?, not * + if 'operands' in inst: + operands = inst['operands'] + last_operand = operands[-1] + + for operand in operands: + if operand != last_operand and 'quantifier' in operand and ('quantifier' not in last_operand or last_operand['quantifier'] != operand['quantifier'] or operand['quantifier'] != '?'): + raise ValueError('quantifier on operand {} in {} but not on last operand'.format(operand['name'], inst['opname'])) + + used_ids += ' break;\n' + + if result < 0: + result = ' result = Id();' + else: + result = ' result = Id::fromWord(it.word({}));'.format(result) + + if resultType < 0: + resultType = ' resultType = Id();' + else: + resultType = ' resultType = Id::fromWord(it.word({}));'.format(resultType) + + op_decoder += ' case rdcspv::Op::{}:{}{} break;\n'.format(inst['opname'][2:], result, resultType) + + used.append(inst['opcode']) + +header.write('''enum class Op : uint16_t +{{ +{decl} + Max, +}}; + +'''.format(decl = decl)) + +ops_header.write(''' +{op_structs} + +template +inline std::string ParamToStr(const std::function &idName, const T &el) +{{ + return ToStr(el); +}} + +template<> +std::string ParamToStr(const std::function &idName, const Id &el); +template<> +std::string ParamToStr(const std::function &idName, const rdcstr &el); +template<> +std::string ParamToStr(const std::function &idName, const PairLiteralIntegerIdRef &el); +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefLiteralInteger &el); +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefIdRef &el); + +{tostr_decls} + +template +inline std::string ParamsToStr(const std::function &idName, const rdcarray &ids) +{{ + std::string ret = "{{"; + for(size_t i=0; i < ids.size(); i++) + {{ + ret += ParamToStr(idName, ids[i]); + if(i + 1 < ids.size()) + ret += ", "; + }} + ret += "}}"; + return ret; +}} + +struct OpDecoder +{{ + OpDecoder(const ConstIter &it); + + static void AddUsedIDs(std::set &usedids, const ConstIter &it); + static std::string Disassemble(const ConstIter &it, const std::function &declName, const std::function &idName, const std::function &constIntVal); + + Op op; + uint16_t wordCount; + Id result; + Id resultType; +}}; +'''.format(op_structs = op_structs.rstrip(), tostr_decls = tostr_decls)) + +cpp.write('''template <> +rdcstr DoStringise(const rdcspv::Op &el) +{{ + BEGIN_ENUM_STRINGISE(rdcspv::Op); + {{ +{stringise} + }} + END_ENUM_STRINGISE(); +}} + +namespace rdcspv +{{ + +template<> +std::string ParamToStr(const std::function &idName, const Id &el) +{{ + return idName(el); +}} + +template<> +std::string ParamToStr(const std::function &idName, const rdcstr &el) +{{ + return "\\"" + el + "\\""; +}} + +template<> +std::string ParamToStr(const std::function &idName, const PairLiteralIntegerIdRef &el) +{{ + return StringFormat::Fmt("[%u, %s]", el.first, idName(el.second).c_str()); +}} + +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefLiteralInteger &el) +{{ + return StringFormat::Fmt("[%s, %u]", idName(el.first).c_str(), el.second); +}} + +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefIdRef &el) +{{ + return StringFormat::Fmt("[%s, %s]", idName(el.first).c_str(), idName(el.second).c_str()); +}} + +{tostrs} + +void OpDecoder::AddUsedIDs(std::set &usedids, const ConstIter &it) +{{ + switch((rdcspv::Op)it.opcode()) + {{ +{used_ids} + case Op::Max: break; + }} +}} + +std::string OpDecoder::Disassemble(const ConstIter &it, const std::function &declName, const std::function &idName, const std::function &constIntVal) +{{ + std::string ret; + switch((rdcspv::Op)it.opcode()) + {{ +{disassemble} + case Op::Max: break; + }} + return ret; +}} + +OpDecoder::OpDecoder(const ConstIter &it) +{{ + op = (rdcspv::Op)it.opcode(); + wordCount = (uint16_t)it.size(); + switch(op) + {{ +{op_decoder} + case Op::Max: break; + }} +}} + +}}; // namespace rdcspv + +'''.format(stringise = stringise.rstrip(), op_decoder = op_decoder.rstrip(), used_ids = used_ids.rstrip(), disassemble = disassemble.rstrip(), tostrs = tostrs.rstrip())); + +############################################################################### +## +## GLSL ext inst set (declare enum) +## +############################################################################### + +decl = '' +stringise = '' + +for inst in glsl450['instructions']: + decl += ' {} = {},\n'.format(inst['opname'], inst['opcode']) + stringise += ' STRINGISE_ENUM_CLASS({});\n'.format(inst['opname']) + +header.write('''enum class GLSLstd450 : uint32_t +{{ +{decl} + Max, + Invalid = ~0U, +}}; + +'''.format(decl = decl)) + +cpp.write('''template <> +rdcstr DoStringise(const rdcspv::GLSLstd450 &el) +{{ + BEGIN_ENUM_STRINGISE(rdcspv::GLSLstd450); + {{ +{stringise} + }} + END_ENUM_STRINGISE(); +}} + +template <> +rdcstr DoStringise(const rdcspv::Generator &el) +{{ + BEGIN_ENUM_STRINGISE(rdcspv::Generator); + {{ +{generator_tostr} + }} + END_ENUM_STRINGISE(); +}} +'''.format(stringise = stringise.rstrip(), generator_tostr = generator_tostr.rstrip())) + +header.write(''' +}; // namespace rdcspv + +DECLARE_STRINGISE_TYPE(rdcspv::GLSLstd450); +DECLARE_STRINGISE_TYPE(rdcspv::Generator); + +''') + +for operand_kind in spirv['operand_kinds']: + if operand_kind['category'] == 'ValueEnum' or operand_kind['category'] == 'BitEnum': + header.write('DECLARE_STRINGISE_TYPE(rdcspv::{});\n'.format(operand_kind['kind'])) + +ops_header.write(''' +}; // namespace rdcspv +''') + +header.close() +ops_header.close() +cpp.close() diff --git a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj index 867b28d7c..47200d201 100644 --- a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj +++ b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj @@ -163,6 +163,7 @@ + @@ -216,6 +217,8 @@ + + diff --git a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters index f9969874e..a035517db 100644 --- a/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters +++ b/renderdoc/driver/shaders/spirv/renderdoc_spirv.vcxproj.filters @@ -10,6 +10,9 @@ {88413a79-d32c-4386-9428-47a9ea0d52b5} + + {1b2858fa-eefd-42e7-af56-bfad5e61e8e9} + @@ -134,6 +137,9 @@ 3rdparty\glslang + + JSON-Generated helpers + @@ -278,8 +284,14 @@ 3rdparty\glslang + + JSON-Generated helpers + + + JSON-Generated helpers + \ No newline at end of file diff --git a/renderdoc/driver/shaders/spirv/spir-v.xml b/renderdoc/driver/shaders/spirv/spir-v.xml new file mode 100644 index 000000000..523460da3 --- /dev/null +++ b/renderdoc/driver/shaders/spirv/spir-v.xml @@ -0,0 +1,145 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/renderdoc/driver/shaders/spirv/spirv.core.grammar.json b/renderdoc/driver/shaders/spirv/spirv.core.grammar.json new file mode 100644 index 000000000..20eafdebc --- /dev/null +++ b/renderdoc/driver/shaders/spirv/spirv.core.grammar.json @@ -0,0 +1,9567 @@ +{ + "copyright" : [ + "Copyright (c) 2014-2016 The Khronos Group Inc.", + "", + "Permission is hereby granted, free of charge, to any person obtaining a copy", + "of this software and/or associated documentation files (the \"Materials\"),", + "to deal in the Materials without restriction, including without limitation", + "the rights to use, copy, modify, merge, publish, distribute, sublicense,", + "and/or sell copies of the Materials, and to permit persons to whom the", + "Materials are furnished to do so, subject to the following conditions:", + "", + "The above copyright notice and this permission notice shall be included in", + "all copies or substantial portions of the Materials.", + "", + "MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS", + "STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND", + "HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ ", + "", + "THE MATERIALS ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS", + "OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,", + "FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL", + "THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER", + "LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING", + "FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS", + "IN THE MATERIALS." + ], + "magic_number" : "0x07230203", + "major_version" : 1, + "minor_version" : 4, + "revision" : 1, + "instructions" : [ + { + "opname" : "OpNop", + "opcode" : 0 + }, + { + "opname" : "OpUndef", + "opcode" : 1, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpSourceContinued", + "opcode" : 2, + "operands" : [ + { "kind" : "LiteralString", "name" : "'Continued Source'" } + ] + }, + { + "opname" : "OpSource", + "opcode" : 3, + "operands" : [ + { "kind" : "SourceLanguage" }, + { "kind" : "LiteralInteger", "name" : "'Version'" }, + { "kind" : "IdRef", "quantifier" : "?", "name" : "'File'" }, + { "kind" : "LiteralString", "quantifier" : "?", "name" : "'Source'" } + ] + }, + { + "opname" : "OpSourceExtension", + "opcode" : 4, + "operands" : [ + { "kind" : "LiteralString", "name" : "'Extension'" } + ] + }, + { + "opname" : "OpName", + "opcode" : 5, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "LiteralString", "name" : "'Name'" } + ] + }, + { + "opname" : "OpMemberName", + "opcode" : 6, + "operands" : [ + { "kind" : "IdRef", "name" : "'Type'" }, + { "kind" : "LiteralInteger", "name" : "'Member'" }, + { "kind" : "LiteralString", "name" : "'Name'" } + ] + }, + { + "opname" : "OpString", + "opcode" : 7, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "LiteralString", "name" : "'String'" } + ] + }, + { + "opname" : "OpLine", + "opcode" : 8, + "operands" : [ + { "kind" : "IdRef", "name" : "'File'" }, + { "kind" : "LiteralInteger", "name" : "'Line'" }, + { "kind" : "LiteralInteger", "name" : "'Column'" } + ] + }, + { + "opname" : "OpExtension", + "opcode" : 10, + "operands" : [ + { "kind" : "LiteralString", "name" : "'Name'" } + ] + }, + { + "opname" : "OpExtInstImport", + "opcode" : 11, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "LiteralString", "name" : "'Name'" } + ] + }, + { + "opname" : "OpExtInst", + "opcode" : 12, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Set'" }, + { "kind" : "LiteralExtInstInteger", "name" : "'Instruction'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Operand 1', +\n'Operand 2', +\n..." } + ] + }, + { + "opname" : "OpMemoryModel", + "opcode" : 14, + "operands" : [ + { "kind" : "AddressingModel" }, + { "kind" : "MemoryModel" } + ] + }, + { + "opname" : "OpEntryPoint", + "opcode" : 15, + "operands" : [ + { "kind" : "ExecutionModel" }, + { "kind" : "IdRef", "name" : "'Entry Point'" }, + { "kind" : "LiteralString", "name" : "'Name'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Interface'" } + ] + }, + { + "opname" : "OpExecutionMode", + "opcode" : 16, + "operands" : [ + { "kind" : "IdRef", "name" : "'Entry Point'" }, + { "kind" : "ExecutionMode", "name" : "'Mode'" } + ] + }, + { + "opname" : "OpCapability", + "opcode" : 17, + "operands" : [ + { "kind" : "Capability", "name" : "'Capability'" } + ] + }, + { + "opname" : "OpTypeVoid", + "opcode" : 19, + "operands" : [ + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpTypeBool", + "opcode" : 20, + "operands" : [ + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpTypeInt", + "opcode" : 21, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "'Width'" }, + { "kind" : "LiteralInteger", "name" : "'Signedness'" } + ] + }, + { + "opname" : "OpTypeFloat", + "opcode" : 22, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "'Width'" } + ] + }, + { + "opname" : "OpTypeVector", + "opcode" : 23, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Component Type'" }, + { "kind" : "LiteralInteger", "name" : "'Component Count'" } + ] + }, + { + "opname" : "OpTypeMatrix", + "opcode" : 24, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Column Type'" }, + { "kind" : "LiteralInteger", "name" : "'Column Count'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpTypeImage", + "opcode" : 25, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Type'" }, + { "kind" : "Dim" }, + { "kind" : "LiteralInteger", "name" : "'Depth'" }, + { "kind" : "LiteralInteger", "name" : "'Arrayed'" }, + { "kind" : "LiteralInteger", "name" : "'MS'" }, + { "kind" : "LiteralInteger", "name" : "'Sampled'" }, + { "kind" : "ImageFormat" }, + { "kind" : "AccessQualifier", "quantifier" : "?" } + ] + }, + { + "opname" : "OpTypeSampler", + "opcode" : 26, + "operands" : [ + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpTypeSampledImage", + "opcode" : 27, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image Type'" } + ] + }, + { + "opname" : "OpTypeArray", + "opcode" : 28, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Element Type'" }, + { "kind" : "IdRef", "name" : "'Length'" } + ] + }, + { + "opname" : "OpTypeRuntimeArray", + "opcode" : 29, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Element Type'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpTypeStruct", + "opcode" : 30, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Member 0 type', +\n'member 1 type', +\n..." } + ] + }, + { + "opname" : "OpTypeOpaque", + "opcode" : 31, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "LiteralString", "name" : "The name of the opaque type." } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpTypePointer", + "opcode" : 32, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "StorageClass" }, + { "kind" : "IdRef", "name" : "'Type'" } + ] + }, + { + "opname" : "OpTypeFunction", + "opcode" : 33, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Return Type'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Parameter 0 Type', +\n'Parameter 1 Type', +\n..." } + ] + }, + { + "opname" : "OpTypeEvent", + "opcode" : 34, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpTypeDeviceEvent", + "opcode" : 35, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpTypeReserveId", + "opcode" : 36, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpTypeQueue", + "opcode" : 37, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpTypePipe", + "opcode" : 38, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "AccessQualifier", "name" : "'Qualifier'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpTypeForwardPointer", + "opcode" : 39, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer Type'" }, + { "kind" : "StorageClass" } + ], + "capabilities" : [ + "Addresses", + "PhysicalStorageBufferAddressesEXT" + ] + }, + { + "opname" : "OpConstantTrue", + "opcode" : 41, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpConstantFalse", + "opcode" : 42, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpConstant", + "opcode" : 43, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralContextDependentNumber", "name" : "'Value'" } + ] + }, + { + "opname" : "OpConstantComposite", + "opcode" : 44, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Constituents'" } + ] + }, + { + "opname" : "OpConstantSampler", + "opcode" : 45, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "SamplerAddressingMode" }, + { "kind" : "LiteralInteger", "name" : "'Param'" }, + { "kind" : "SamplerFilterMode" } + ], + "capabilities" : [ "LiteralSampler" ] + }, + { + "opname" : "OpConstantNull", + "opcode" : 46, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpSpecConstantTrue", + "opcode" : 48, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpSpecConstantFalse", + "opcode" : 49, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpSpecConstant", + "opcode" : 50, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralContextDependentNumber", "name" : "'Value'" } + ] + }, + { + "opname" : "OpSpecConstantComposite", + "opcode" : 51, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Constituents'" } + ] + }, + { + "opname" : "OpSpecConstantOp", + "opcode" : 52, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralSpecConstantOpInteger", "name" : "'Opcode'" } + ] + }, + { + "opname" : "OpFunction", + "opcode" : 54, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "FunctionControl" }, + { "kind" : "IdRef", "name" : "'Function Type'" } + ] + }, + { + "opname" : "OpFunctionParameter", + "opcode" : 55, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpFunctionEnd", + "opcode" : 56 + }, + { + "opname" : "OpFunctionCall", + "opcode" : 57, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Function'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Argument 0', +\n'Argument 1', +\n..." } + ] + }, + { + "opname" : "OpVariable", + "opcode" : 59, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "StorageClass" }, + { "kind" : "IdRef", "quantifier" : "?", "name" : "'Initializer'" } + ] + }, + { + "opname" : "OpImageTexelPointer", + "opcode" : 60, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Sample'" } + ] + }, + { + "opname" : "OpLoad", + "opcode" : 61, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "MemoryAccess", "quantifier" : "?" } + ] + }, + { + "opname" : "OpStore", + "opcode" : 62, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Object'" }, + { "kind" : "MemoryAccess", "quantifier" : "?" } + ] + }, + { + "opname" : "OpCopyMemory", + "opcode" : 63, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "IdRef", "name" : "'Source'" }, + { "kind" : "MemoryAccess", "quantifier" : "?" }, + { "kind" : "MemoryAccess", "quantifier" : "?" } + ] + }, + { + "opname" : "OpCopyMemorySized", + "opcode" : 64, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "IdRef", "name" : "'Source'" }, + { "kind" : "IdRef", "name" : "'Size'" }, + { "kind" : "MemoryAccess", "quantifier" : "?" }, + { "kind" : "MemoryAccess", "quantifier" : "?" } + ], + "capabilities" : [ "Addresses" ] + }, + { + "opname" : "OpAccessChain", + "opcode" : 65, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" } + ] + }, + { + "opname" : "OpInBoundsAccessChain", + "opcode" : 66, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" } + ] + }, + { + "opname" : "OpPtrAccessChain", + "opcode" : 67, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Element'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" } + ], + "capabilities" : [ + "Addresses", + "VariablePointers", + "VariablePointersStorageBuffer", + "PhysicalStorageBufferAddressesEXT" + ] + }, + { + "opname" : "OpArrayLength", + "opcode" : 68, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Structure'" }, + { "kind" : "LiteralInteger", "name" : "'Array member'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpGenericPtrMemSemantics", + "opcode" : 69, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpInBoundsPtrAccessChain", + "opcode" : 70, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Element'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" } + ], + "capabilities" : [ "Addresses" ] + }, + { + "opname" : "OpDecorate", + "opcode" : 71, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "Decoration" } + ] + }, + { + "opname" : "OpMemberDecorate", + "opcode" : 72, + "operands" : [ + { "kind" : "IdRef", "name" : "'Structure Type'" }, + { "kind" : "LiteralInteger", "name" : "'Member'" }, + { "kind" : "Decoration" } + ] + }, + { + "opname" : "OpDecorationGroup", + "opcode" : 73, + "operands" : [ + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpGroupDecorate", + "opcode" : 74, + "operands" : [ + { "kind" : "IdRef", "name" : "'Decoration Group'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Targets'" } + ] + }, + { + "opname" : "OpGroupMemberDecorate", + "opcode" : 75, + "operands" : [ + { "kind" : "IdRef", "name" : "'Decoration Group'" }, + { "kind" : "PairIdRefLiteralInteger", "quantifier" : "*", "name" : "'Targets'" } + ] + }, + { + "opname" : "OpVectorExtractDynamic", + "opcode" : 77, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector'" }, + { "kind" : "IdRef", "name" : "'Index'" } + ] + }, + { + "opname" : "OpVectorInsertDynamic", + "opcode" : 78, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector'" }, + { "kind" : "IdRef", "name" : "'Component'" }, + { "kind" : "IdRef", "name" : "'Index'" } + ] + }, + { + "opname" : "OpVectorShuffle", + "opcode" : 79, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector 1'" }, + { "kind" : "IdRef", "name" : "'Vector 2'" }, + { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Components'" } + ] + }, + { + "opname" : "OpCompositeConstruct", + "opcode" : 80, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Constituents'" } + ] + }, + { + "opname" : "OpCompositeExtract", + "opcode" : 81, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Composite'" }, + { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Indexes'" } + ] + }, + { + "opname" : "OpCompositeInsert", + "opcode" : 82, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Object'" }, + { "kind" : "IdRef", "name" : "'Composite'" }, + { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Indexes'" } + ] + }, + { + "opname" : "OpCopyObject", + "opcode" : 83, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ] + }, + { + "opname" : "OpTranspose", + "opcode" : 84, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Matrix'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpSampledImage", + "opcode" : 86, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Sampler'" } + ] + }, + { + "opname" : "OpImageSampleImplicitLod", + "opcode" : 87, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageSampleExplicitLod", + "opcode" : 88, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands" } + ] + }, + { + "opname" : "OpImageSampleDrefImplicitLod", + "opcode" : 89, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageSampleDrefExplicitLod", + "opcode" : 90, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageSampleProjImplicitLod", + "opcode" : 91, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageSampleProjExplicitLod", + "opcode" : 92, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageSampleProjDrefImplicitLod", + "opcode" : 93, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageSampleProjDrefExplicitLod", + "opcode" : 94, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageFetch", + "opcode" : 95, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ] + }, + { + "opname" : "OpImageGather", + "opcode" : 96, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Component'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageDrefGather", + "opcode" : 97, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpImageRead", + "opcode" : 98, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ] + }, + { + "opname" : "OpImageWrite", + "opcode" : 99, + "operands" : [ + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Texel'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ] + }, + { + "opname" : "OpImage", + "opcode" : 100, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" } + ] + }, + { + "opname" : "OpImageQueryFormat", + "opcode" : 101, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpImageQueryOrder", + "opcode" : 102, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpImageQuerySizeLod", + "opcode" : 103, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Level of Detail'" } + ], + "capabilities" : [ "Kernel", "ImageQuery" ] + }, + { + "opname" : "OpImageQuerySize", + "opcode" : 104, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" } + ], + "capabilities" : [ "Kernel", "ImageQuery" ] + }, + { + "opname" : "OpImageQueryLod", + "opcode" : 105, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" } + ], + "capabilities" : [ "ImageQuery" ] + }, + { + "opname" : "OpImageQueryLevels", + "opcode" : 106, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" } + ], + "capabilities" : [ "Kernel", "ImageQuery" ] + }, + { + "opname" : "OpImageQuerySamples", + "opcode" : 107, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" } + ], + "capabilities" : [ "Kernel", "ImageQuery" ] + }, + { + "opname" : "OpConvertFToU", + "opcode" : 109, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Float Value'" } + ] + }, + { + "opname" : "OpConvertFToS", + "opcode" : 110, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Float Value'" } + ] + }, + { + "opname" : "OpConvertSToF", + "opcode" : 111, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Signed Value'" } + ] + }, + { + "opname" : "OpConvertUToF", + "opcode" : 112, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Unsigned Value'" } + ] + }, + { + "opname" : "OpUConvert", + "opcode" : 113, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Unsigned Value'" } + ] + }, + { + "opname" : "OpSConvert", + "opcode" : 114, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Signed Value'" } + ] + }, + { + "opname" : "OpFConvert", + "opcode" : 115, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Float Value'" } + ] + }, + { + "opname" : "OpQuantizeToF16", + "opcode" : 116, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpConvertPtrToU", + "opcode" : 117, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" } + ], + "capabilities" : [ + "Addresses", + "PhysicalStorageBufferAddressesEXT" + ] + }, + { + "opname" : "OpSatConvertSToU", + "opcode" : 118, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Signed Value'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpSatConvertUToS", + "opcode" : 119, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Unsigned Value'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpConvertUToPtr", + "opcode" : 120, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Integer Value'" } + ], + "capabilities" : [ + "Addresses", + "PhysicalStorageBufferAddressesEXT" + ] + }, + { + "opname" : "OpPtrCastToGeneric", + "opcode" : 121, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpGenericCastToPtr", + "opcode" : 122, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpGenericCastToPtrExplicit", + "opcode" : 123, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "StorageClass", "name" : "'Storage'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpBitcast", + "opcode" : 124, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ] + }, + { + "opname" : "OpSNegate", + "opcode" : 126, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ] + }, + { + "opname" : "OpFNegate", + "opcode" : 127, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ] + }, + { + "opname" : "OpIAdd", + "opcode" : 128, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFAdd", + "opcode" : 129, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpISub", + "opcode" : 130, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFSub", + "opcode" : 131, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpIMul", + "opcode" : 132, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFMul", + "opcode" : 133, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpUDiv", + "opcode" : 134, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSDiv", + "opcode" : 135, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFDiv", + "opcode" : 136, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpUMod", + "opcode" : 137, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSRem", + "opcode" : 138, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSMod", + "opcode" : 139, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFRem", + "opcode" : 140, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFMod", + "opcode" : 141, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpVectorTimesScalar", + "opcode" : 142, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector'" }, + { "kind" : "IdRef", "name" : "'Scalar'" } + ] + }, + { + "opname" : "OpMatrixTimesScalar", + "opcode" : 143, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Matrix'" }, + { "kind" : "IdRef", "name" : "'Scalar'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpVectorTimesMatrix", + "opcode" : 144, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector'" }, + { "kind" : "IdRef", "name" : "'Matrix'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpMatrixTimesVector", + "opcode" : 145, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Matrix'" }, + { "kind" : "IdRef", "name" : "'Vector'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpMatrixTimesMatrix", + "opcode" : 146, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'LeftMatrix'" }, + { "kind" : "IdRef", "name" : "'RightMatrix'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpOuterProduct", + "opcode" : 147, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector 1'" }, + { "kind" : "IdRef", "name" : "'Vector 2'" } + ], + "capabilities" : [ "Matrix" ] + }, + { + "opname" : "OpDot", + "opcode" : 148, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector 1'" }, + { "kind" : "IdRef", "name" : "'Vector 2'" } + ] + }, + { + "opname" : "OpIAddCarry", + "opcode" : 149, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpISubBorrow", + "opcode" : 150, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpUMulExtended", + "opcode" : 151, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSMulExtended", + "opcode" : 152, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpAny", + "opcode" : 154, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector'" } + ] + }, + { + "opname" : "OpAll", + "opcode" : 155, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Vector'" } + ] + }, + { + "opname" : "OpIsNan", + "opcode" : 156, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "OpIsInf", + "opcode" : 157, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" } + ] + }, + { + "opname" : "OpIsFinite", + "opcode" : 158, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpIsNormal", + "opcode" : 159, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpSignBitSet", + "opcode" : 160, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpLessOrGreater", + "opcode" : 161, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpOrdered", + "opcode" : 162, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpUnordered", + "opcode" : 163, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'x'" }, + { "kind" : "IdRef", "name" : "'y'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpLogicalEqual", + "opcode" : 164, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpLogicalNotEqual", + "opcode" : 165, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpLogicalOr", + "opcode" : 166, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpLogicalAnd", + "opcode" : 167, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpLogicalNot", + "opcode" : 168, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ] + }, + { + "opname" : "OpSelect", + "opcode" : 169, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Condition'" }, + { "kind" : "IdRef", "name" : "'Object 1'" }, + { "kind" : "IdRef", "name" : "'Object 2'" } + ] + }, + { + "opname" : "OpIEqual", + "opcode" : 170, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpINotEqual", + "opcode" : 171, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpUGreaterThan", + "opcode" : 172, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSGreaterThan", + "opcode" : 173, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpUGreaterThanEqual", + "opcode" : 174, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSGreaterThanEqual", + "opcode" : 175, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpULessThan", + "opcode" : 176, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSLessThan", + "opcode" : 177, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpULessThanEqual", + "opcode" : 178, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpSLessThanEqual", + "opcode" : 179, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFOrdEqual", + "opcode" : 180, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFUnordEqual", + "opcode" : 181, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFOrdNotEqual", + "opcode" : 182, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFUnordNotEqual", + "opcode" : 183, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFOrdLessThan", + "opcode" : 184, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFUnordLessThan", + "opcode" : 185, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFOrdGreaterThan", + "opcode" : 186, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFUnordGreaterThan", + "opcode" : 187, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFOrdLessThanEqual", + "opcode" : 188, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFUnordLessThanEqual", + "opcode" : 189, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFOrdGreaterThanEqual", + "opcode" : 190, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpFUnordGreaterThanEqual", + "opcode" : 191, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpShiftRightLogical", + "opcode" : 194, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Shift'" } + ] + }, + { + "opname" : "OpShiftRightArithmetic", + "opcode" : 195, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Shift'" } + ] + }, + { + "opname" : "OpShiftLeftLogical", + "opcode" : 196, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Shift'" } + ] + }, + { + "opname" : "OpBitwiseOr", + "opcode" : 197, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpBitwiseXor", + "opcode" : 198, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpBitwiseAnd", + "opcode" : 199, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ] + }, + { + "opname" : "OpNot", + "opcode" : 200, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ] + }, + { + "opname" : "OpBitFieldInsert", + "opcode" : 201, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Insert'" }, + { "kind" : "IdRef", "name" : "'Offset'" }, + { "kind" : "IdRef", "name" : "'Count'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpBitFieldSExtract", + "opcode" : 202, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Offset'" }, + { "kind" : "IdRef", "name" : "'Count'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpBitFieldUExtract", + "opcode" : 203, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" }, + { "kind" : "IdRef", "name" : "'Offset'" }, + { "kind" : "IdRef", "name" : "'Count'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpBitReverse", + "opcode" : 204, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpBitCount", + "opcode" : 205, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Base'" } + ] + }, + { + "opname" : "OpDPdx", + "opcode" : 207, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpDPdy", + "opcode" : 208, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpFwidth", + "opcode" : 209, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpDPdxFine", + "opcode" : 210, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "DerivativeControl" ] + }, + { + "opname" : "OpDPdyFine", + "opcode" : 211, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "DerivativeControl" ] + }, + { + "opname" : "OpFwidthFine", + "opcode" : 212, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "DerivativeControl" ] + }, + { + "opname" : "OpDPdxCoarse", + "opcode" : 213, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "DerivativeControl" ] + }, + { + "opname" : "OpDPdyCoarse", + "opcode" : 214, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "DerivativeControl" ] + }, + { + "opname" : "OpFwidthCoarse", + "opcode" : 215, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'P'" } + ], + "capabilities" : [ "DerivativeControl" ] + }, + { + "opname" : "OpEmitVertex", + "opcode" : 218, + "capabilities" : [ "Geometry" ] + }, + { + "opname" : "OpEndPrimitive", + "opcode" : 219, + "capabilities" : [ "Geometry" ] + }, + { + "opname" : "OpEmitStreamVertex", + "opcode" : 220, + "operands" : [ + { "kind" : "IdRef", "name" : "'Stream'" } + ], + "capabilities" : [ "GeometryStreams" ] + }, + { + "opname" : "OpEndStreamPrimitive", + "opcode" : 221, + "operands" : [ + { "kind" : "IdRef", "name" : "'Stream'" } + ], + "capabilities" : [ "GeometryStreams" ] + }, + { + "opname" : "OpControlBarrier", + "opcode" : 224, + "operands" : [ + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ] + }, + { + "opname" : "OpMemoryBarrier", + "opcode" : 225, + "operands" : [ + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ] + }, + { + "opname" : "OpAtomicLoad", + "opcode" : 227, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ] + }, + { + "opname" : "OpAtomicStore", + "opcode" : 228, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicExchange", + "opcode" : 229, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicCompareExchange", + "opcode" : 230, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Equal'" }, + { "kind" : "IdMemorySemantics", "name" : "'Unequal'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Comparator'" } + ] + }, + { + "opname" : "OpAtomicCompareExchangeWeak", + "opcode" : 231, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Equal'" }, + { "kind" : "IdMemorySemantics", "name" : "'Unequal'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Comparator'" } + ], + "capabilities" : [ "Kernel" ], + "lastVersion" : "1.3" + }, + { + "opname" : "OpAtomicIIncrement", + "opcode" : 232, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ] + }, + { + "opname" : "OpAtomicIDecrement", + "opcode" : 233, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ] + }, + { + "opname" : "OpAtomicIAdd", + "opcode" : 234, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicISub", + "opcode" : 235, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicSMin", + "opcode" : 236, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicUMin", + "opcode" : 237, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicSMax", + "opcode" : 238, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicUMax", + "opcode" : 239, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicAnd", + "opcode" : 240, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicOr", + "opcode" : 241, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpAtomicXor", + "opcode" : 242, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpPhi", + "opcode" : 245, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "PairIdRefIdRef", "quantifier" : "*", "name" : "'Variable, Parent, ...'" } + ] + }, + { + "opname" : "OpLoopMerge", + "opcode" : 246, + "operands" : [ + { "kind" : "IdRef", "name" : "'Merge Block'" }, + { "kind" : "IdRef", "name" : "'Continue Target'" }, + { "kind" : "LoopControl" } + ] + }, + { + "opname" : "OpSelectionMerge", + "opcode" : 247, + "operands" : [ + { "kind" : "IdRef", "name" : "'Merge Block'" }, + { "kind" : "SelectionControl" } + ] + }, + { + "opname" : "OpLabel", + "opcode" : 248, + "operands" : [ + { "kind" : "IdResult" } + ] + }, + { + "opname" : "OpBranch", + "opcode" : 249, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target Label'" } + ] + }, + { + "opname" : "OpBranchConditional", + "opcode" : 250, + "operands" : [ + { "kind" : "IdRef", "name" : "'Condition'" }, + { "kind" : "IdRef", "name" : "'True Label'" }, + { "kind" : "IdRef", "name" : "'False Label'" }, + { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Branch weights'" } + ] + }, + { + "opname" : "OpSwitch", + "opcode" : 251, + "operands" : [ + { "kind" : "IdRef", "name" : "'Selector'" }, + { "kind" : "IdRef", "name" : "'Default'" }, + { "kind" : "PairLiteralIntegerIdRef", "quantifier" : "*", "name" : "'Target'" } + ] + }, + { + "opname" : "OpKill", + "opcode" : 252, + "capabilities" : [ "Shader" ] + }, + { + "opname" : "OpReturn", + "opcode" : 253 + }, + { + "opname" : "OpReturnValue", + "opcode" : 254, + "operands" : [ + { "kind" : "IdRef", "name" : "'Value'" } + ] + }, + { + "opname" : "OpUnreachable", + "opcode" : 255 + }, + { + "opname" : "OpLifetimeStart", + "opcode" : 256, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "LiteralInteger", "name" : "'Size'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpLifetimeStop", + "opcode" : 257, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "LiteralInteger", "name" : "'Size'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpGroupAsyncCopy", + "opcode" : 259, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Destination'" }, + { "kind" : "IdRef", "name" : "'Source'" }, + { "kind" : "IdRef", "name" : "'Num Elements'" }, + { "kind" : "IdRef", "name" : "'Stride'" }, + { "kind" : "IdRef", "name" : "'Event'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpGroupWaitEvents", + "opcode" : 260, + "operands" : [ + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Num Events'" }, + { "kind" : "IdRef", "name" : "'Events List'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpGroupAll", + "opcode" : 261, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupAny", + "opcode" : 262, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupBroadcast", + "opcode" : 263, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'LocalId'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupIAdd", + "opcode" : 264, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupFAdd", + "opcode" : 265, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupFMin", + "opcode" : 266, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupUMin", + "opcode" : 267, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupSMin", + "opcode" : 268, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupFMax", + "opcode" : 269, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupUMax", + "opcode" : 270, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpGroupSMax", + "opcode" : 271, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ] + }, + { + "opname" : "OpReadPipe", + "opcode" : 274, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpWritePipe", + "opcode" : 275, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpReservedReadPipe", + "opcode" : 276, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" }, + { "kind" : "IdRef", "name" : "'Index'" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpReservedWritePipe", + "opcode" : 277, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" }, + { "kind" : "IdRef", "name" : "'Index'" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpReserveReadPipePackets", + "opcode" : 278, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Num Packets'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpReserveWritePipePackets", + "opcode" : 279, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Num Packets'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpCommitReadPipe", + "opcode" : 280, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpCommitWritePipe", + "opcode" : 281, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpIsValidReserveId", + "opcode" : 282, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpGetNumPipePackets", + "opcode" : 283, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpGetMaxPipePackets", + "opcode" : 284, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpGroupReserveReadPipePackets", + "opcode" : 285, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Num Packets'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpGroupReserveWritePipePackets", + "opcode" : 286, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Num Packets'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpGroupCommitReadPipe", + "opcode" : 287, + "operands" : [ + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpGroupCommitWritePipe", + "opcode" : 288, + "operands" : [ + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Pipe'" }, + { "kind" : "IdRef", "name" : "'Reserve Id'" }, + { "kind" : "IdRef", "name" : "'Packet Size'" }, + { "kind" : "IdRef", "name" : "'Packet Alignment'" } + ], + "capabilities" : [ "Pipes" ] + }, + { + "opname" : "OpEnqueueMarker", + "opcode" : 291, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Queue'" }, + { "kind" : "IdRef", "name" : "'Num Events'" }, + { "kind" : "IdRef", "name" : "'Wait Events'" }, + { "kind" : "IdRef", "name" : "'Ret Event'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpEnqueueKernel", + "opcode" : 292, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Queue'" }, + { "kind" : "IdRef", "name" : "'Flags'" }, + { "kind" : "IdRef", "name" : "'ND Range'" }, + { "kind" : "IdRef", "name" : "'Num Events'" }, + { "kind" : "IdRef", "name" : "'Wait Events'" }, + { "kind" : "IdRef", "name" : "'Ret Event'" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" }, + { "kind" : "IdRef", "quantifier" : "*", "name" : "'Local Size'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpGetKernelNDrangeSubGroupCount", + "opcode" : 293, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'ND Range'" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpGetKernelNDrangeMaxSubGroupSize", + "opcode" : 294, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'ND Range'" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpGetKernelWorkGroupSize", + "opcode" : 295, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpGetKernelPreferredWorkGroupSizeMultiple", + "opcode" : 296, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpRetainEvent", + "opcode" : 297, + "operands" : [ + { "kind" : "IdRef", "name" : "'Event'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpReleaseEvent", + "opcode" : 298, + "operands" : [ + { "kind" : "IdRef", "name" : "'Event'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpCreateUserEvent", + "opcode" : 299, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpIsValidEvent", + "opcode" : 300, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Event'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpSetUserEventStatus", + "opcode" : 301, + "operands" : [ + { "kind" : "IdRef", "name" : "'Event'" }, + { "kind" : "IdRef", "name" : "'Status'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpCaptureEventProfilingInfo", + "opcode" : 302, + "operands" : [ + { "kind" : "IdRef", "name" : "'Event'" }, + { "kind" : "IdRef", "name" : "'Profiling Info'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpGetDefaultQueue", + "opcode" : 303, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpBuildNDRange", + "opcode" : 304, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'GlobalWorkSize'" }, + { "kind" : "IdRef", "name" : "'LocalWorkSize'" }, + { "kind" : "IdRef", "name" : "'GlobalWorkOffset'" } + ], + "capabilities" : [ "DeviceEnqueue" ] + }, + { + "opname" : "OpImageSparseSampleImplicitLod", + "opcode" : 305, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseSampleExplicitLod", + "opcode" : 306, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseSampleDrefImplicitLod", + "opcode" : 307, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseSampleDrefExplicitLod", + "opcode" : 308, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseSampleProjImplicitLod", + "opcode" : 309, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ], + "version" : "None" + }, + { + "opname" : "OpImageSparseSampleProjExplicitLod", + "opcode" : 310, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "SparseResidency" ], + "version" : "None" + }, + { + "opname" : "OpImageSparseSampleProjDrefImplicitLod", + "opcode" : 311, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ], + "version" : "None" + }, + { + "opname" : "OpImageSparseSampleProjDrefExplicitLod", + "opcode" : 312, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands" } + ], + "capabilities" : [ "SparseResidency" ], + "version" : "None" + }, + { + "opname" : "OpImageSparseFetch", + "opcode" : 313, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseGather", + "opcode" : 314, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Component'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseDrefGather", + "opcode" : 315, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'D~ref~'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpImageSparseTexelsResident", + "opcode" : 316, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Resident Code'" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpNoLine", + "opcode" : 317 + }, + { + "opname" : "OpAtomicFlagTestAndSet", + "opcode" : 318, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpAtomicFlagClear", + "opcode" : 319, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ], + "capabilities" : [ "Kernel" ] + }, + { + "opname" : "OpImageSparseRead", + "opcode" : 320, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "SparseResidency" ] + }, + { + "opname" : "OpSizeOf", + "opcode" : 321, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" } + ], + "capabilities" : [ "Addresses" ], + "version" : "1.1" + }, + { + "opname" : "OpTypePipeStorage", + "opcode" : 322, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "PipeStorage" ], + "version" : "1.1" + }, + { + "opname" : "OpConstantPipeStorage", + "opcode" : 323, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "LiteralInteger", "name" : "'Packet Size'" }, + { "kind" : "LiteralInteger", "name" : "'Packet Alignment'" }, + { "kind" : "LiteralInteger", "name" : "'Capacity'" } + ], + "capabilities" : [ "PipeStorage" ], + "version" : "1.1" + }, + { + "opname" : "OpCreatePipeFromPipeStorage", + "opcode" : 324, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pipe Storage'" } + ], + "capabilities" : [ "PipeStorage" ], + "version" : "1.1" + }, + { + "opname" : "OpGetKernelLocalSizeForSubgroupCount", + "opcode" : 325, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Subgroup Count'" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" } + ], + "capabilities" : [ "SubgroupDispatch" ], + "version" : "1.1" + }, + { + "opname" : "OpGetKernelMaxNumSubgroups", + "opcode" : 326, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Invoke'" }, + { "kind" : "IdRef", "name" : "'Param'" }, + { "kind" : "IdRef", "name" : "'Param Size'" }, + { "kind" : "IdRef", "name" : "'Param Align'" } + ], + "capabilities" : [ "SubgroupDispatch" ], + "version" : "1.1" + }, + { + "opname" : "OpTypeNamedBarrier", + "opcode" : 327, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "NamedBarrier" ], + "version" : "1.1" + }, + { + "opname" : "OpNamedBarrierInitialize", + "opcode" : 328, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Subgroup Count'" } + ], + "capabilities" : [ "NamedBarrier" ], + "version" : "1.1" + }, + { + "opname" : "OpMemoryNamedBarrier", + "opcode" : 329, + "operands" : [ + { "kind" : "IdRef", "name" : "'Named Barrier'" }, + { "kind" : "IdScope", "name" : "'Memory'" }, + { "kind" : "IdMemorySemantics", "name" : "'Semantics'" } + ], + "capabilities" : [ "NamedBarrier" ], + "version" : "1.1" + }, + { + "opname" : "OpModuleProcessed", + "opcode" : 330, + "operands" : [ + { "kind" : "LiteralString", "name" : "'Process'" } + ], + "version" : "1.1" + }, + { + "opname" : "OpExecutionModeId", + "opcode" : 331, + "operands" : [ + { "kind" : "IdRef", "name" : "'Entry Point'" }, + { "kind" : "ExecutionMode", "name" : "'Mode'" } + ], + "version" : "1.2" + }, + { + "opname" : "OpDecorateId", + "opcode" : 332, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "Decoration" } + ], + "extensions" : [ "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "1.2" + }, + { + "opname" : "OpGroupNonUniformElect", + "opcode" : 333, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" } + ], + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformAll", + "opcode" : 334, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "capabilities" : [ "GroupNonUniformVote" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformAny", + "opcode" : 335, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "capabilities" : [ "GroupNonUniformVote" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformAllEqual", + "opcode" : 336, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformVote" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBroadcast", + "opcode" : 337, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Id'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBroadcastFirst", + "opcode" : 338, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBallot", + "opcode" : 339, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformInverseBallot", + "opcode" : 340, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBallotBitExtract", + "opcode" : 341, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Index'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBallotBitCount", + "opcode" : 342, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBallotFindLSB", + "opcode" : 343, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBallotFindMSB", + "opcode" : 344, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformShuffle", + "opcode" : 345, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Id'" } + ], + "capabilities" : [ "GroupNonUniformShuffle" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformShuffleXor", + "opcode" : 346, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Mask'" } + ], + "capabilities" : [ "GroupNonUniformShuffle" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformShuffleUp", + "opcode" : 347, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Delta'" } + ], + "capabilities" : [ "GroupNonUniformShuffleRelative" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformShuffleDown", + "opcode" : 348, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Delta'" } + ], + "capabilities" : [ "GroupNonUniformShuffleRelative" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformIAdd", + "opcode" : 349, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformFAdd", + "opcode" : 350, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformIMul", + "opcode" : 351, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformFMul", + "opcode" : 352, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformSMin", + "opcode" : 353, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformUMin", + "opcode" : 354, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformFMin", + "opcode" : 355, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformSMax", + "opcode" : 356, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformUMax", + "opcode" : 357, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformFMax", + "opcode" : 358, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBitwiseAnd", + "opcode" : 359, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBitwiseOr", + "opcode" : 360, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformBitwiseXor", + "opcode" : 361, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformLogicalAnd", + "opcode" : 362, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformLogicalOr", + "opcode" : 363, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformLogicalXor", + "opcode" : 364, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'ClusterSize'", "quantifier" : "?" } + ], + "capabilities" : [ "GroupNonUniformArithmetic", "GroupNonUniformClustered", "GroupNonUniformPartitionedNV" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformQuadBroadcast", + "opcode" : 365, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Index'" } + ], + "capabilities" : [ "GroupNonUniformQuad" ], + "version" : "1.3" + }, + { + "opname" : "OpGroupNonUniformQuadSwap", + "opcode" : 366, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Direction'" } + ], + "capabilities" : [ "GroupNonUniformQuad" ], + "version" : "1.3" + }, + { + "opname" : "OpCopyLogical", + "opcode" : 400, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ], + "version" : "1.4" + }, + { + "opname" : "OpPtrEqual", + "opcode" : 401, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "version" : "1.4" + }, + { + "opname" : "OpPtrNotEqual", + "opcode" : 402, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "version" : "1.4" + }, + { + "opname" : "OpPtrDiff", + "opcode" : 403, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "Addresses", "VariablePointers", "VariablePointersStorageBuffer" ], + "version" : "1.4" + }, + { + "opname" : "OpSubgroupBallotKHR", + "opcode" : 4421, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "capabilities" : [ "SubgroupBallotKHR" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupFirstInvocationKHR", + "opcode" : 4422, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "SubgroupBallotKHR" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAllKHR", + "opcode" : 4428, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "extensions" : [ + "SPV_KHR_subgroup_vote" + ], + "capabilities" : [ "SubgroupVoteKHR" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAnyKHR", + "opcode" : 4429, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "extensions" : [ + "SPV_KHR_subgroup_vote" + ], + "capabilities" : [ "SubgroupVoteKHR" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAllEqualKHR", + "opcode" : 4430, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Predicate'" } + ], + "extensions" : [ + "SPV_KHR_subgroup_vote" + ], + "capabilities" : [ "SubgroupVoteKHR" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupReadInvocationKHR", + "opcode" : 4432, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Value'" }, + { "kind" : "IdRef", "name" : "'Index'" } + ], + "capabilities" : [ "SubgroupBallotKHR" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupIAddNonUniformAMD", + "opcode" : 5000, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupFAddNonUniformAMD", + "opcode" : 5001, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupFMinNonUniformAMD", + "opcode" : 5002, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupUMinNonUniformAMD", + "opcode" : 5003, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupSMinNonUniformAMD", + "opcode" : 5004, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupFMaxNonUniformAMD", + "opcode" : 5005, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupUMaxNonUniformAMD", + "opcode" : 5006, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpGroupSMaxNonUniformAMD", + "opcode" : 5007, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "GroupOperation", "name" : "'Operation'" }, + { "kind" : "IdRef", "name" : "'X'" } + ], + "capabilities" : [ "Groups" ], + "extensions" : [ "SPV_AMD_shader_ballot" ], + "version" : "None" + }, + { + "opname" : "OpFragmentMaskFetchAMD", + "opcode" : 5011, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" } + ], + "capabilities" : [ "FragmentMaskAMD" ], + "extensions" : [ "SPV_AMD_shader_fragment_mask" ], + "version" : "None" + }, + { + "opname" : "OpFragmentFetchAMD", + "opcode" : 5012, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Fragment Index'" } + ], + "capabilities" : [ "FragmentMaskAMD" ], + "extensions" : [ "SPV_AMD_shader_fragment_mask" ], + "version" : "None" + }, + { + "opname" : "OpReadClockKHR", + "opcode" : 5056, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdScope", "name" : "'Execution'" } + ], + "capabilities" : [ "ShaderClockKHR" ], + "extensions" : [ "SPV_KHR_shader_clock" ], + "version" : "None" + }, + { + "opname" : "OpImageSampleFootprintNV", + "opcode" : 5283, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Sampled Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Granularity'" }, + { "kind" : "IdRef", "name" : "'Coarse'" }, + { "kind" : "ImageOperands", "quantifier" : "?" } + ], + "capabilities" : [ "ImageFootprintNV" ], + "extensions" : [ "SPV_NV_shader_image_footprint" ], + "version" : "None" + }, + { + "opname" : "OpGroupNonUniformPartitionNV", + "opcode" : 5296, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "GroupNonUniformPartitionedNV" ], + "extensions" : [ "SPV_NV_shader_subgroup_partitioned" ], + "version" : "None" + }, + { + "opname" : "OpWritePackedPrimitiveIndices4x8NV", + "opcode" : 5299, + "operands" : [ + { "kind" : "IdRef", "name" : "'Index Offset'" }, + { "kind" : "IdRef", "name" : "'Packed Indices'" } + ], + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "opname" : "OpReportIntersectionNV", + "opcode" : 5334, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Hit'" }, + { "kind" : "IdRef", "name" : "'HitKind'" } + ], + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ] + }, + { + "opname" : "OpIgnoreIntersectionNV", + "opcode" : 5335, + + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ] + }, + { + "opname" : "OpTerminateRayNV", + "opcode" : 5336, + + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ] + }, + { + "opname" : "OpTraceNV", + "opcode" : 5337, + "operands" : [ + + { "kind" : "IdRef", "name" : "'Accel'" }, + { "kind" : "IdRef", "name" : "'Ray Flags'" }, + { "kind" : "IdRef", "name" : "'Cull Mask'" }, + { "kind" : "IdRef", "name" : "'SBT Offset'" }, + { "kind" : "IdRef", "name" : "'SBT Stride'" }, + { "kind" : "IdRef", "name" : "'Miss Index'" }, + { "kind" : "IdRef", "name" : "'Ray Origin'" }, + { "kind" : "IdRef", "name" : "'Ray Tmin'" }, + { "kind" : "IdRef", "name" : "'Ray Direction'" }, + { "kind" : "IdRef", "name" : "'Ray Tmax'" }, + { "kind" : "IdRef", "name" : "'PayloadId'" } + ], + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ] + }, + { + "opname" : "OpTypeAccelerationStructureNV", + "opcode" : 5341, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ] + }, + { + "opname" : "OpExecuteCallableNV", + "opcode" : 5344, + "operands" : [ + + { "kind" : "IdRef", "name" : "'SBT Index'" }, + { "kind" : "IdRef", "name" : "'Callable DataId'" } + ], + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ] + }, + { + "opname" : "OpTypeCooperativeMatrixNV", + "opcode" : 5358, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Component Type'" }, + { "kind" : "IdScope", "name" : "'Execution'" }, + { "kind" : "IdRef", "name" : "'Rows'" }, + { "kind" : "IdRef", "name" : "'Columns'" } + ], + "capabilities" : [ "CooperativeMatrixNV" ], + "extensions" : [ "SPV_NV_cooperative_matrix" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixLoadNV", + "opcode" : 5359, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Stride'" }, + { "kind" : "IdRef", "name" : "'Column Major'" }, + { "kind" : "MemoryAccess", "quantifier" : "?" } + ], + "capabilities" : [ "CooperativeMatrixNV" ], + "extensions" : [ "SPV_NV_cooperative_matrix" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixStoreNV", + "opcode" : 5360, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Object'" }, + { "kind" : "IdRef", "name" : "'Stride'" }, + { "kind" : "IdRef", "name" : "'Column Major'" }, + { "kind" : "MemoryAccess", "quantifier" : "?" } + ], + "capabilities" : [ "CooperativeMatrixNV" ], + "extensions" : [ "SPV_NV_cooperative_matrix" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixMulAddNV", + "opcode" : 5361, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'A'" }, + { "kind" : "IdRef", "name" : "'B'" }, + { "kind" : "IdRef", "name" : "'C'" } + ], + "capabilities" : [ "CooperativeMatrixNV" ], + "extensions" : [ "SPV_NV_cooperative_matrix" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixLengthNV", + "opcode" : 5362, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Type'" } + ], + "capabilities" : [ "CooperativeMatrixNV" ], + "extensions" : [ "SPV_NV_cooperative_matrix" ], + "version" : "None" + }, + { + "opname" : "OpBeginInvocationInterlockEXT", + "opcode" : 5364, + "capabilities" : [ "FragmentShaderSampleInterlockEXT", "FragmentShaderPixelInterlockEXT", "FragmentShaderShadingRateInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "opname" : "OpEndInvocationInterlockEXT", + "opcode" : 5365, + "capabilities" : [ "FragmentShaderSampleInterlockEXT", "FragmentShaderPixelInterlockEXT", "FragmentShaderShadingRateInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "opname" : "OpDemoteToHelperInvocationEXT", + "opcode" : 5380, + "capabilities" : [ "DemoteToHelperInvocationEXT" ], + "extensions" : [ "SPV_EXT_demote_to_helper_invocation" ], + "version" : "None" + }, + { + "opname" : "OpIsHelperInvocationEXT", + "opcode" : 5381, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "DemoteToHelperInvocationEXT" ], + "extensions" : [ "SPV_EXT_demote_to_helper_invocation" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupShuffleINTEL", + "opcode" : 5571, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Data'" }, + { "kind" : "IdRef", "name" : "'InvocationId'" } + ], + "capabilities" : [ "SubgroupShuffleINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupShuffleDownINTEL", + "opcode" : 5572, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Current'" }, + { "kind" : "IdRef", "name" : "'Next'" }, + { "kind" : "IdRef", "name" : "'Delta'" } + ], + "capabilities" : [ "SubgroupShuffleINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupShuffleUpINTEL", + "opcode" : 5573, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Previous'" }, + { "kind" : "IdRef", "name" : "'Current'" }, + { "kind" : "IdRef", "name" : "'Delta'" } + ], + "capabilities" : [ "SubgroupShuffleINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupShuffleXorINTEL", + "opcode" : 5574, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Data'" }, + { "kind" : "IdRef", "name" : "'Value'" } + ], + "capabilities" : [ "SubgroupShuffleINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupBlockReadINTEL", + "opcode" : 5575, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Ptr'" } + ], + "capabilities" : [ "SubgroupBufferBlockIOINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupBlockWriteINTEL", + "opcode" : 5576, + "operands" : [ + { "kind" : "IdRef", "name" : "'Ptr'" }, + { "kind" : "IdRef", "name" : "'Data'" } + ], + "capabilities" : [ "SubgroupBufferBlockIOINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupImageBlockReadINTEL", + "opcode" : 5577, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" } + ], + "capabilities" : [ "SubgroupImageBlockIOINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupImageBlockWriteINTEL", + "opcode" : 5578, + "operands" : [ + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Data'" } + ], + "capabilities" : [ "SubgroupImageBlockIOINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupImageMediaBlockReadINTEL", + "opcode" : 5580, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Width'" }, + { "kind" : "IdRef", "name" : "'Height'" } + ], + "capabilities" : [ "SubgroupImageMediaBlockIOINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupImageMediaBlockWriteINTEL", + "opcode" : 5581, + "operands" : [ + { "kind" : "IdRef", "name" : "'Image'" }, + { "kind" : "IdRef", "name" : "'Coordinate'" }, + { "kind" : "IdRef", "name" : "'Width'" }, + { "kind" : "IdRef", "name" : "'Height'" }, + { "kind" : "IdRef", "name" : "'Data'" } + ], + "capabilities" : [ "SubgroupImageMediaBlockIOINTEL" ], + "version" : "None" + }, + { + "opname" : "OpUCountLeadingZerosINTEL", + "opcode" : 5585, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpUCountTrailingZerosINTEL", + "opcode" : 5586, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpAbsISubINTEL", + "opcode" : 5587, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpAbsUSubINTEL", + "opcode" : 5588, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpIAddSatINTEL", + "opcode" : 5589, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpUAddSatINTEL", + "opcode" : 5590, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpIAverageINTEL", + "opcode" : 5591, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpUAverageINTEL", + "opcode" : 5592, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpIAverageRoundedINTEL", + "opcode" : 5593, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpUAverageRoundedINTEL", + "opcode" : 5594, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpISubSatINTEL", + "opcode" : 5595, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpUSubSatINTEL", + "opcode" : 5596, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpIMul32x16INTEL", + "opcode" : 5597, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpUMul32x16INTEL", + "opcode" : 5598, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Operand 1'" }, + { "kind" : "IdRef", "name" : "'Operand 2'" } + ], + "capabilities" : [ "IntegerFunctions2INTEL" ], + "version" : "None" + }, + { + "opname" : "OpDecorateString", + "opcode" : 5632, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "Decoration" } + ], + "extensions" : [ "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "1.4" + }, + { + "opname" : "OpDecorateStringGOOGLE", + "opcode" : 5632, + "operands" : [ + { "kind" : "IdRef", "name" : "'Target'" }, + { "kind" : "Decoration" } + ], + "extensions" : [ "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "1.4" + }, + { + "opname" : "OpMemberDecorateString", + "opcode" : 5633, + "operands" : [ + { "kind" : "IdRef", "name" : "'Struct Type'" }, + { "kind" : "LiteralInteger", "name" : "'Member'" }, + { "kind" : "Decoration" } + ], + "extensions" : [ "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "1.4" + }, + { + "opname" : "OpMemberDecorateStringGOOGLE", + "opcode" : 5633, + "operands" : [ + { "kind" : "IdRef", "name" : "'Struct Type'" }, + { "kind" : "LiteralInteger", "name" : "'Member'" }, + { "kind" : "Decoration" } + ], + "extensions" : [ "SPV_GOOGLE_decorate_string", "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "1.4" + }, + { + "opname" : "OpVmeImageINTEL", + "opcode" : 5699, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image Type'" }, + { "kind" : "IdRef", "name" : "'Sampler'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeVmeImageINTEL", + "opcode" : 5700, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image Type'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcImePayloadINTEL", + "opcode" : 5701, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcRefPayloadINTEL", + "opcode" : 5702, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcSicPayloadINTEL", + "opcode" : 5703, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcMcePayloadINTEL", + "opcode" : 5704, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcMceResultINTEL", + "opcode" : 5705, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcImeResultINTEL", + "opcode" : 5706, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcImeResultSingleReferenceStreamoutINTEL", + "opcode" : 5707, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcImeResultDualReferenceStreamoutINTEL", + "opcode" : 5708, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcImeSingleReferenceStreaminINTEL", + "opcode" : 5709, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcImeDualReferenceStreaminINTEL", + "opcode" : 5710, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcRefResultINTEL", + "opcode" : 5711, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpTypeAvcSicResultINTEL", + "opcode" : 5712, + "operands" : [ + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", + "opcode" : 5713, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Slice Type'" }, + { "kind" : "IdRef", "name" : "'Qp'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", + "opcode" : 5714, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Reference Base Penalty'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", + "opcode" : 5715, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Slice Type'" }, + { "kind" : "IdRef", "name" : "'Qp'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetInterShapePenaltyINTEL", + "opcode" : 5716, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Packed Shape Penalty'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", + "opcode" : 5717, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Slice Type'" }, + { "kind" : "IdRef", "name" : "'Qp'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", + "opcode" : 5718, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Direction Cost'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", + "opcode" : 5719, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Slice Type'" }, + { "kind" : "IdRef", "name" : "'Qp'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", + "opcode" : 5720, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Slice Type'" }, + { "kind" : "IdRef", "name" : "'Qp'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", + "opcode" : 5721, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", + "opcode" : 5722, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", + "opcode" : 5723, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", + "opcode" : 5724, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Packed Cost Center Delta'" }, + { "kind" : "IdRef", "name" : "'Packed Cost Table'" }, + { "kind" : "IdRef", "name" : "'Cost Precision'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", + "opcode" : 5725, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Slice Type'" }, + { "kind" : "IdRef", "name" : "'Qp'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", + "opcode" : 5726, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", + "opcode" : 5727, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationChromaINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetAcOnlyHaarINTEL", + "opcode" : 5728, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", + "opcode" : 5729, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Source Field Polarity'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", + "opcode" : 5730, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Reference Field Polarity'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", + "opcode" : 5731, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Forward Reference Field Polarity'" }, + { "kind" : "IdRef", "name" : "'Backward Reference Field Polarity'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceConvertToImePayloadINTEL", + "opcode" : 5732, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceConvertToImeResultINTEL", + "opcode" : 5733, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceConvertToRefPayloadINTEL", + "opcode" : 5734, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceConvertToRefResultINTEL", + "opcode" : 5735, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceConvertToSicPayloadINTEL", + "opcode" : 5736, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceConvertToSicResultINTEL", + "opcode" : 5737, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetMotionVectorsINTEL", + "opcode" : 5738, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterDistortionsINTEL", + "opcode" : 5739, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetBestInterDistortionsINTEL", + "opcode" : 5740, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterMajorShapeINTEL", + "opcode" : 5741, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterMinorShapeINTEL", + "opcode" : 5742, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterDirectionsINTEL", + "opcode" : 5743, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterMotionVectorCountINTEL", + "opcode" : 5744, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterReferenceIdsINTEL", + "opcode" : 5745, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", + "opcode" : 5746, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Packed Reference Ids'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Parameter Field Polarities'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeInitializeINTEL", + "opcode" : 5747, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Coord'" }, + { "kind" : "IdRef", "name" : "'Partition Mask'" }, + { "kind" : "IdRef", "name" : "'SAD Adjustment'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeSetSingleReferenceINTEL", + "opcode" : 5748, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Ref Offset'" }, + { "kind" : "IdRef", "name" : "'Search Window Config'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeSetDualReferenceINTEL", + "opcode" : 5749, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Offset'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Offset'" }, + { "kind" : "IdRef", "name" : "'id> Search Window Config'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeRefWindowSizeINTEL", + "opcode" : 5750, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Search Window Config'" }, + { "kind" : "IdRef", "name" : "'Dual Ref'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeAdjustRefOffsetINTEL", + "opcode" : 5751, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Ref Offset'" }, + { "kind" : "IdRef", "name" : "'Src Coord'" }, + { "kind" : "IdRef", "name" : "'Ref Window Size'" }, + { "kind" : "IdRef", "name" : "'Image Size'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeConvertToMcePayloadINTEL", + "opcode" : 5752, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", + "opcode" : 5753, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Max Motion Vector Count'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", + "opcode" : 5754, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", + "opcode" : 5755, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Threshold'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeSetWeightedSadINTEL", + "opcode" : 5756, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Packed Sad Weights'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", + "opcode" : 5757, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", + "opcode" : 5758, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", + "opcode" : 5759, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Streamin Components'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", + "opcode" : 5760, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Streamin Components'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", + "opcode" : 5761, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", + "opcode" : 5762, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", + "opcode" : 5763, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Streamin Components'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", + "opcode" : 5764, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Streamin Components'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeConvertToMceResultINTEL", + "opcode" : 5765, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", + "opcode" : 5766, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetDualReferenceStreaminINTEL", + "opcode" : 5767, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", + "opcode" : 5768, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", + "opcode" : 5769, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", + "opcode" : 5770, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Major Shape'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", + "opcode" : 5771, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Major Shape'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", + "opcode" : 5772, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Major Shape'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", + "opcode" : 5773, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Major Shape'" }, + { "kind" : "IdRef", "name" : "'Direction'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", + "opcode" : 5774, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Major Shape'" }, + { "kind" : "IdRef", "name" : "'Direction'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", + "opcode" : 5775, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" }, + { "kind" : "IdRef", "name" : "'Major Shape'" }, + { "kind" : "IdRef", "name" : "'Direction'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetBorderReachedINTEL", + "opcode" : 5776, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Image Select'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", + "opcode" : 5777, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", + "opcode" : 5778, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", + "opcode" : 5779, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", + "opcode" : 5780, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcFmeInitializeINTEL", + "opcode" : 5781, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Coord'" }, + { "kind" : "IdRef", "name" : "'Motion Vectors'" }, + { "kind" : "IdRef", "name" : "'Major Shapes'" }, + { "kind" : "IdRef", "name" : "'Minor Shapes'" }, + { "kind" : "IdRef", "name" : "'Direction'" }, + { "kind" : "IdRef", "name" : "'Pixel Resolution'" }, + { "kind" : "IdRef", "name" : "'Sad Adjustment'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcBmeInitializeINTEL", + "opcode" : 5782, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Coord'" }, + { "kind" : "IdRef", "name" : "'Motion Vectors'" }, + { "kind" : "IdRef", "name" : "'Major Shapes'" }, + { "kind" : "IdRef", "name" : "'Minor Shapes'" }, + { "kind" : "IdRef", "name" : "'Direction'" }, + { "kind" : "IdRef", "name" : "'Pixel Resolution'" }, + { "kind" : "IdRef", "name" : "'Bidirectional Weight'" }, + { "kind" : "IdRef", "name" : "'Sad Adjustment'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefConvertToMcePayloadINTEL", + "opcode" : 5783, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", + "opcode" : 5784, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefSetBilinearFilterEnableINTEL", + "opcode" : 5785, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", + "opcode" : 5786, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", + "opcode" : 5787, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", + "opcode" : 5788, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Ids'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", + "opcode" : 5789, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Ids'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Field Polarities'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcRefConvertToMceResultINTEL", + "opcode" : 5790, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicInitializeINTEL", + "opcode" : 5791, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Coord'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicConfigureSkcINTEL", + "opcode" : 5792, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Skip Block Partition Type'" }, + { "kind" : "IdRef", "name" : "'Skip Motion Vector Mask'" }, + { "kind" : "IdRef", "name" : "'Motion Vectors'" }, + { "kind" : "IdRef", "name" : "'Bidirectional Weight'" }, + { "kind" : "IdRef", "name" : "'Sad Adjustment'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicConfigureIpeLumaINTEL", + "opcode" : 5793, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Luma Intra Partition Mask'" }, + { "kind" : "IdRef", "name" : "'Intra Neighbour Availabilty'" }, + { "kind" : "IdRef", "name" : "'Left Edge Luma Pixels'" }, + { "kind" : "IdRef", "name" : "'Upper Left Corner Luma Pixel'" }, + { "kind" : "IdRef", "name" : "'Upper Edge Luma Pixels'" }, + { "kind" : "IdRef", "name" : "'Upper Right Edge Luma Pixels'" }, + { "kind" : "IdRef", "name" : "'Sad Adjustment'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", + "opcode" : 5794, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Luma Intra Partition Mask'" }, + { "kind" : "IdRef", "name" : "'Intra Neighbour Availabilty'" }, + { "kind" : "IdRef", "name" : "'Left Edge Luma Pixels'" }, + { "kind" : "IdRef", "name" : "'Upper Left Corner Luma Pixel'" }, + { "kind" : "IdRef", "name" : "'Upper Edge Luma Pixels'" }, + { "kind" : "IdRef", "name" : "'Upper Right Edge Luma Pixels'" }, + { "kind" : "IdRef", "name" : "'Left Edge Chroma Pixels'" }, + { "kind" : "IdRef", "name" : "'Upper Left Corner Chroma Pixel'" }, + { "kind" : "IdRef", "name" : "'Upper Edge Chroma Pixels'" }, + { "kind" : "IdRef", "name" : "'Sad Adjustment'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationChromaINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetMotionVectorMaskINTEL", + "opcode" : 5795, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Skip Block Partition Type'" }, + { "kind" : "IdRef", "name" : "'Direction'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicConvertToMcePayloadINTEL", + "opcode" : 5796, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", + "opcode" : 5797, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Packed Shape Penalty'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", + "opcode" : 5798, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Luma Mode Penalty'" }, + { "kind" : "IdRef", "name" : "'Luma Packed Neighbor Modes'" }, + { "kind" : "IdRef", "name" : "'Luma Packed Non Dc Penalty'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", + "opcode" : 5799, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Chroma Mode Base Penalty'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationChromaINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicSetBilinearFilterEnableINTEL", + "opcode" : 5800, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", + "opcode" : 5801, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Packed Sad Coefficients'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", + "opcode" : 5802, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Block Based Skip Type'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicEvaluateIpeINTEL", + "opcode" : 5803, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", + "opcode" : 5804, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", + "opcode" : 5805, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Fwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Bwd Ref Image'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", + "opcode" : 5806, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Ids'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", + "opcode" : 5807, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Src Image'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Ids'" }, + { "kind" : "IdRef", "name" : "'Packed Reference Field Polarities'" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicConvertToMceResultINTEL", + "opcode" : 5808, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetIpeLumaShapeINTEL", + "opcode" : 5809, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", + "opcode" : 5810, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", + "opcode" : 5811, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", + "opcode" : 5812, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetIpeChromaModeINTEL", + "opcode" : 5813, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationChromaINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", + "opcode" : 5814, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", + "opcode" : 5815, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL", "SubgroupAvcMotionEstimationIntraINTEL" ], + "version" : "None" + }, + { + "opname" : "OpSubgroupAvcSicGetInterRawSadsINTEL", + "opcode" : 5816, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Payload'" } + ], + "capabilities" : [ "SubgroupAvcMotionEstimationINTEL" ], + "version" : "None" + } + ], + "operand_kinds" : [ + { + "category" : "BitEnum", + "kind" : "ImageOperands", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "Bias", + "value" : "0x0001", + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "Lod", + "value" : "0x0002", + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "Grad", + "value" : "0x0004", + "parameters" : [ + { "kind" : "IdRef" }, + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "ConstOffset", + "value" : "0x0008", + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "Offset", + "value" : "0x0010", + "capabilities" : [ "ImageGatherExtended" ], + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "ConstOffsets", + "value" : "0x0020", + "capabilities" : [ "ImageGatherExtended" ], + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "Sample", + "value" : "0x0040", + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "MinLod", + "value" : "0x0080", + "capabilities" : [ "MinLod" ], + "parameters" : [ + { "kind" : "IdRef" } + ] + }, + { + "enumerant" : "MakeTexelAvailableKHR", + "value" : "0x0100", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "parameters" : [ + { "kind" : "IdScope" } + ], + "version" : "None" + }, + { + "enumerant" : "MakeTexelVisibleKHR", + "value" : "0x0200", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "parameters" : [ + { "kind" : "IdScope" } + ], + "version" : "None" + }, + { + "enumerant" : "NonPrivateTexelKHR", + "value" : "0x0400", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "VolatileTexelKHR", + "value" : "0x0800", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "SignExtend", + "value" : "0x1000", + "version" : "1.4" + }, + { + "enumerant" : "ZeroExtend", + "value" : "0x2000", + "version" : "1.4" + } + ] + }, + { + "category" : "BitEnum", + "kind" : "FPFastMathMode", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "NotNaN", + "value" : "0x0001", + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NotInf", + "value" : "0x0002", + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NSZ", + "value" : "0x0004", + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "AllowRecip", + "value" : "0x0008", + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Fast", + "value" : "0x0010", + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "BitEnum", + "kind" : "SelectionControl", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "Flatten", + "value" : "0x0001" + }, + { + "enumerant" : "DontFlatten", + "value" : "0x0002" + } + ] + }, + { + "category" : "BitEnum", + "kind" : "LoopControl", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "Unroll", + "value" : "0x0001" + }, + { + "enumerant" : "DontUnroll", + "value" : "0x0002" + }, + { + "enumerant" : "DependencyInfinite", + "value" : "0x0004", + "version" : "1.1" + }, + { + "enumerant" : "DependencyLength", + "value" : "0x0008", + "parameters" : [ + { "kind" : "LiteralInteger" } + ], + "version" : "1.1" + }, + { + "enumerant" : "MinIterations", + "value" : "0x0010", + "parameters" : [ + { "kind" : "LiteralInteger" } + ], + "version" : "1.4" + }, + { + "enumerant" : "MaxIterations", + "value" : "0x0020", + "parameters" : [ + { "kind" : "LiteralInteger" } + ], + "version" : "1.4" + }, + { + "enumerant" : "IterationMultiple", + "value" : "0x0040", + "parameters" : [ + { "kind" : "LiteralInteger" } + ], + "version" : "1.4" + }, + { + "enumerant" : "PeelCount", + "value" : "0x0080", + "parameters" : [ + { "kind" : "LiteralInteger" } + ], + "version" : "1.4" + }, + { + "enumerant" : "PartialCount", + "value" : "0x0100", + "parameters" : [ + { "kind" : "LiteralInteger" } + ], + "version" : "1.4" + } + ] + }, + { + "category" : "BitEnum", + "kind" : "FunctionControl", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "Inline", + "value" : "0x0001" + }, + { + "enumerant" : "DontInline", + "value" : "0x0002" + }, + { + "enumerant" : "Pure", + "value" : "0x0004" + }, + { + "enumerant" : "Const", + "value" : "0x0008" + } + ] + }, + { + "category" : "BitEnum", + "kind" : "MemorySemantics", + "enumerants" : [ + { + "enumerant" : "Relaxed", + "value" : "0x0000" + }, + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "Acquire", + "value" : "0x0002" + }, + { + "enumerant" : "Release", + "value" : "0x0004" + }, + { + "enumerant" : "AcquireRelease", + "value" : "0x0008" + }, + { + "enumerant" : "SequentiallyConsistent", + "value" : "0x0010" + }, + { + "enumerant" : "UniformMemory", + "value" : "0x0040", + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SubgroupMemory", + "value" : "0x0080" + }, + { + "enumerant" : "WorkgroupMemory", + "value" : "0x0100" + }, + { + "enumerant" : "CrossWorkgroupMemory", + "value" : "0x0200" + }, + { + "enumerant" : "AtomicCounterMemory", + "value" : "0x0400", + "capabilities" : [ "AtomicStorage" ] + }, + { + "enumerant" : "ImageMemory", + "value" : "0x0800" + }, + { + "enumerant" : "OutputMemoryKHR", + "value" : "0x1000", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "MakeAvailableKHR", + "value" : "0x2000", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "MakeVisibleKHR", + "value" : "0x4000", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "Volatile", + "value" : "0x8000", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + } + ] + }, + { + "category" : "BitEnum", + "kind" : "MemoryAccess", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "Volatile", + "value" : "0x0001" + }, + { + "enumerant" : "Aligned", + "value" : "0x0002", + "parameters" : [ + { "kind" : "LiteralInteger" } + ] + }, + { + "enumerant" : "Nontemporal", + "value" : "0x0004" + }, + { + "enumerant" : "MakePointerAvailableKHR", + "value" : "0x0008", + "parameters" : [ + { "kind" : "IdScope" } + ], + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "MakePointerVisibleKHR", + "value" : "0x0010", + "parameters" : [ + { "kind" : "IdScope" } + ], + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + }, + { + "enumerant" : "NonPrivatePointerKHR", + "value" : "0x0020", + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + } + ] + }, + { + "category" : "BitEnum", + "kind" : "KernelProfilingInfo", + "enumerants" : [ + { + "enumerant" : "None", + "value" : "0x0000" + }, + { + "enumerant" : "CmdExecTime", + "value" : "0x0001", + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "SourceLanguage", + "enumerants" : [ + { + "enumerant" : "Unknown", + "value" : 0 + }, + { + "enumerant" : "ESSL", + "value" : 1 + }, + { + "enumerant" : "GLSL", + "value" : 2 + }, + { + "enumerant" : "OpenCL_C", + "value" : 3 + }, + { + "enumerant" : "OpenCL_CPP", + "value" : 4 + }, + { + "enumerant" : "HLSL", + "value" : 5 + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "ExecutionModel", + "enumerants" : [ + { + "enumerant" : "Vertex", + "value" : 0, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "TessellationControl", + "value" : 1, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "TessellationEvaluation", + "value" : 2, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "Geometry", + "value" : 3, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "Fragment", + "value" : 4, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "GLCompute", + "value" : 5, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Kernel", + "value" : 6, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "TaskNV", + "value" : 5267, + "capabilities" : [ "MeshShadingNV" ], + "version" : "None" + }, + { + "enumerant" : "MeshNV", + "value" : 5268, + "capabilities" : [ "MeshShadingNV" ], + "version" : "None" + }, + { + "enumerant" : "RayGenerationNV", + "value" : 5313, + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "IntersectionNV", + "value" : 5314, + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "AnyHitNV", + "value" : 5315, + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "ClosestHitNV", + "value" : 5316, + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "MissNV", + "value" : 5317, + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "CallableNV", + "value" : 5318, + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "AddressingModel", + "enumerants" : [ + { + "enumerant" : "Logical", + "value" : 0 + }, + { + "enumerant" : "Physical32", + "value" : 1, + "capabilities" : [ "Addresses" ] + }, + { + "enumerant" : "Physical64", + "value" : 2, + "capabilities" : [ "Addresses" ] + }, + { + "enumerant" : "PhysicalStorageBuffer64EXT", + "value" : 5348, + "extensions" : [ "SPV_EXT_physical_storage_buffer" ], + "capabilities" : [ "PhysicalStorageBufferAddressesEXT" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "MemoryModel", + "enumerants" : [ + { + "enumerant" : "Simple", + "value" : 0, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "GLSL450", + "value" : 1, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "OpenCL", + "value" : 2, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "VulkanKHR", + "value" : 3, + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "ExecutionMode", + "enumerants" : [ + { + "enumerant" : "Invocations", + "value" : 0, + "capabilities" : [ "Geometry" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Number of <>'" } + ] + }, + { + "enumerant" : "SpacingEqual", + "value" : 1, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "SpacingFractionalEven", + "value" : 2, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "SpacingFractionalOdd", + "value" : 3, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "VertexOrderCw", + "value" : 4, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "VertexOrderCcw", + "value" : 5, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "PixelCenterInteger", + "value" : 6, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "OriginUpperLeft", + "value" : 7, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "OriginLowerLeft", + "value" : 8, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "EarlyFragmentTests", + "value" : 9, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "PointMode", + "value" : 10, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "Xfb", + "value" : 11, + "capabilities" : [ "TransformFeedback" ] + }, + { + "enumerant" : "DepthReplacing", + "value" : 12, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "DepthGreater", + "value" : 14, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "DepthLess", + "value" : 15, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "DepthUnchanged", + "value" : 16, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "LocalSize", + "value" : 17, + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'x size'" }, + { "kind" : "LiteralInteger", "name" : "'y size'" }, + { "kind" : "LiteralInteger", "name" : "'z size'" } + ] + }, + { + "enumerant" : "LocalSizeHint", + "value" : 18, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'x size'" }, + { "kind" : "LiteralInteger", "name" : "'y size'" }, + { "kind" : "LiteralInteger", "name" : "'z size'" } + ] + }, + { + "enumerant" : "InputPoints", + "value" : 19, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "InputLines", + "value" : 20, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "InputLinesAdjacency", + "value" : 21, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "Triangles", + "value" : 22, + "capabilities" : [ "Geometry", "Tessellation" ] + }, + { + "enumerant" : "InputTrianglesAdjacency", + "value" : 23, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "Quads", + "value" : 24, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "Isolines", + "value" : 25, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "OutputVertices", + "value" : 26, + "capabilities" : [ "Geometry", "Tessellation", "MeshShadingNV" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Vertex count'" } + ] + }, + { + "enumerant" : "OutputPoints", + "value" : 27, + "capabilities" : [ "Geometry", "MeshShadingNV" ] + }, + { + "enumerant" : "OutputLineStrip", + "value" : 28, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "OutputTriangleStrip", + "value" : 29, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "VecTypeHint", + "value" : 30, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Vector type'" } + ] + }, + { + "enumerant" : "ContractionOff", + "value" : 31, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Initializer", + "value" : 33, + "capabilities" : [ "Kernel" ], + "version" : "1.1" + }, + { + "enumerant" : "Finalizer", + "value" : 34, + "capabilities" : [ "Kernel" ], + "version" : "1.1" + }, + { + "enumerant" : "SubgroupSize", + "value" : 35, + "capabilities" : [ "SubgroupDispatch" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Subgroup Size'" } + ], + "version" : "1.1" + }, + { + "enumerant" : "SubgroupsPerWorkgroup", + "value" : 36, + "capabilities" : [ "SubgroupDispatch" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Subgroups Per Workgroup'" } + ], + "version" : "1.1" + }, + { + "enumerant" : "SubgroupsPerWorkgroupId", + "value" : 37, + "capabilities" : [ "SubgroupDispatch" ], + "parameters" : [ + { "kind" : "IdRef", "name" : "'Subgroups Per Workgroup'" } + ], + "version" : "1.2" + }, + { + "enumerant" : "LocalSizeId", + "value" : 38, + "parameters" : [ + { "kind" : "IdRef", "name" : "'x size'" }, + { "kind" : "IdRef", "name" : "'y size'" }, + { "kind" : "IdRef", "name" : "'z size'" } + ], + "version" : "1.2" + }, + { + "enumerant" : "LocalSizeHintId", + "value" : 39, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "IdRef", "name" : "'Local Size Hint'" } + ], + "version" : "1.2" + }, + { + "enumerant" : "PostDepthCoverage", + "value" : 4446, + "capabilities" : [ "SampleMaskPostDepthCoverage" ], + "extensions" : [ "SPV_KHR_post_depth_coverage" ], + "version" : "None" + }, + { + "enumerant" : "DenormPreserve", + "value" : 4459, + "capabilities" : [ "DenormPreserve" ], + "extensions" : [ "SPV_KHR_float_controls" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Target Width'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "DenormFlushToZero", + "value" : 4460, + "capabilities" : [ "DenormFlushToZero" ], + "extensions" : [ "SPV_KHR_float_controls" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Target Width'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "SignedZeroInfNanPreserve", + "value" : 4461, + "capabilities" : [ "SignedZeroInfNanPreserve" ], + "extensions" : [ "SPV_KHR_float_controls" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Target Width'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "RoundingModeRTE", + "value" : 4462, + "capabilities" : [ "RoundingModeRTE" ], + "extensions" : [ "SPV_KHR_float_controls" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Target Width'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "RoundingModeRTZ", + "value" : 4463, + "capabilities" : [ "RoundingModeRTZ" ], + "extensions" : [ "SPV_KHR_float_controls" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Target Width'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "StencilRefReplacingEXT", + "value" : 5027, + "capabilities" : [ "StencilExportEXT" ], + "extensions" : [ "SPV_EXT_shader_stencil_export" ], + "version" : "None" + }, + { + "enumerant" : "OutputLinesNV", + "value" : 5269, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "OutputPrimitivesNV", + "value" : 5270, + "capabilities" : [ "MeshShadingNV" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Primitive count'" } + ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "DerivativeGroupQuadsNV", + "value" : 5289, + "capabilities" : [ "ComputeDerivativeGroupQuadsNV" ], + "extensions" : [ "SPV_NV_compute_shader_derivatives" ], + "version" : "None" + }, + { + "enumerant" : "DerivativeGroupLinearNV", + "value" : 5290, + "capabilities" : [ "ComputeDerivativeGroupLinearNV" ], + "extensions" : [ "SPV_NV_compute_shader_derivatives" ], + "version" : "None" + }, + { + "enumerant" : "OutputTrianglesNV", + "value" : 5298, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "PixelInterlockOrderedEXT", + "value" : 5366, + "capabilities" : [ "FragmentShaderPixelInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "PixelInterlockUnorderedEXT", + "value" : 5367, + "capabilities" : [ "FragmentShaderPixelInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "SampleInterlockOrderedEXT", + "value" : 5368, + "capabilities" : [ "FragmentShaderSampleInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "SampleInterlockUnorderedEXT", + "value" : 5369, + "capabilities" : [ "FragmentShaderSampleInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "ShadingRateInterlockOrderedEXT", + "value" : 5370, + "capabilities" : [ "FragmentShaderShadingRateInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "ShadingRateInterlockUnorderedEXT", + "value" : 5371, + "capabilities" : [ "FragmentShaderShadingRateInterlockEXT" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "StorageClass", + "enumerants" : [ + { + "enumerant" : "UniformConstant", + "value" : 0 + }, + { + "enumerant" : "Input", + "value" : 1 + }, + { + "enumerant" : "Uniform", + "value" : 2, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Output", + "value" : 3, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Workgroup", + "value" : 4 + }, + { + "enumerant" : "CrossWorkgroup", + "value" : 5 + }, + { + "enumerant" : "Private", + "value" : 6, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Function", + "value" : 7 + }, + { + "enumerant" : "Generic", + "value" : 8, + "capabilities" : [ "GenericPointer" ] + }, + { + "enumerant" : "PushConstant", + "value" : 9, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "AtomicCounter", + "value" : 10, + "capabilities" : [ "AtomicStorage" ] + }, + { + "enumerant" : "Image", + "value" : 11 + }, + { + "enumerant" : "StorageBuffer", + "value" : 12, + "extensions" : [ + "SPV_KHR_storage_buffer_storage_class", + "SPV_KHR_variable_pointers" + ], + "capabilities" : [ "Shader" ], + "version" : "1.3" + }, + { + "enumerant" : "CallableDataNV", + "value" : 5328, + "extensions" : [ "SPV_NV_ray_tracing" ], + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "IncomingCallableDataNV", + "value" : 5329, + "extensions" : [ "SPV_NV_ray_tracing" ], + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "RayPayloadNV", + "value" : 5338, + "extensions" : [ "SPV_NV_ray_tracing" ], + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "HitAttributeNV", + "value" : 5339, + "extensions" : [ "SPV_NV_ray_tracing" ], + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "IncomingRayPayloadNV", + "value" : 5342, + "extensions" : [ "SPV_NV_ray_tracing" ], + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "ShaderRecordBufferNV", + "value" : 5343, + "extensions" : [ "SPV_NV_ray_tracing" ], + "capabilities" : [ "RayTracingNV" ], + "version" : "None" + }, + { + "enumerant" : "PhysicalStorageBufferEXT", + "value" : 5349, + "extensions" : [ "SPV_EXT_physical_storage_buffer" ], + "capabilities" : [ "PhysicalStorageBufferAddressesEXT" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "Dim", + "enumerants" : [ + { + "enumerant" : "1D", + "value" : 0, + "capabilities" : [ "Sampled1D", "Image1D" ] + }, + { + "enumerant" : "2D", + "value" : 1, + "capabilities" : [ "Shader", "Kernel", "ImageMSArray" ] + }, + { + "enumerant" : "3D", + "value" : 2 + }, + { + "enumerant" : "Cube", + "value" : 3, + "capabilities" : [ "Shader", "ImageCubeArray" ] + }, + { + "enumerant" : "Rect", + "value" : 4, + "capabilities" : [ "SampledRect", "ImageRect" ] + }, + { + "enumerant" : "Buffer", + "value" : 5, + "capabilities" : [ "SampledBuffer", "ImageBuffer" ] + }, + { + "enumerant" : "SubpassData", + "value" : 6, + "capabilities" : [ "InputAttachment" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "SamplerAddressingMode", + "enumerants" : [ + { + "enumerant" : "None", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "ClampToEdge", + "value" : 1, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Clamp", + "value" : 2, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Repeat", + "value" : 3, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RepeatMirrored", + "value" : 4, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "SamplerFilterMode", + "enumerants" : [ + { + "enumerant" : "Nearest", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Linear", + "value" : 1, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "ImageFormat", + "enumerants" : [ + { + "enumerant" : "Unknown", + "value" : 0 + }, + { + "enumerant" : "Rgba32f", + "value" : 1, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba16f", + "value" : 2, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "R32f", + "value" : 3, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba8", + "value" : 4, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba8Snorm", + "value" : 5, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rg32f", + "value" : 6, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg16f", + "value" : 7, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R11fG11fB10f", + "value" : 8, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R16f", + "value" : 9, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rgba16", + "value" : 10, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rgb10A2", + "value" : 11, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg16", + "value" : 12, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg8", + "value" : 13, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R16", + "value" : 14, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R8", + "value" : 15, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rgba16Snorm", + "value" : 16, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg16Snorm", + "value" : 17, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg8Snorm", + "value" : 18, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R16Snorm", + "value" : 19, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R8Snorm", + "value" : 20, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rgba32i", + "value" : 21, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba16i", + "value" : 22, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba8i", + "value" : 23, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "R32i", + "value" : 24, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rg32i", + "value" : 25, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg16i", + "value" : 26, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg8i", + "value" : 27, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R16i", + "value" : 28, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R8i", + "value" : 29, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rgba32ui", + "value" : 30, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba16ui", + "value" : 31, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgba8ui", + "value" : 32, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "R32ui", + "value" : 33, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Rgb10a2ui", + "value" : 34, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg32ui", + "value" : 35, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg16ui", + "value" : 36, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "Rg8ui", + "value" : 37, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R16ui", + "value" : 38, + "capabilities" : [ "StorageImageExtendedFormats" ] + }, + { + "enumerant" : "R8ui", + "value" : 39, + "capabilities" : [ "StorageImageExtendedFormats" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "ImageChannelOrder", + "enumerants" : [ + { + "enumerant" : "R", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "A", + "value" : 1, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RG", + "value" : 2, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RA", + "value" : 3, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RGB", + "value" : 4, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RGBA", + "value" : 5, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "BGRA", + "value" : 6, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "ARGB", + "value" : 7, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Intensity", + "value" : 8, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Luminance", + "value" : 9, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Rx", + "value" : 10, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RGx", + "value" : 11, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "RGBx", + "value" : 12, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Depth", + "value" : 13, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "DepthStencil", + "value" : 14, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "sRGB", + "value" : 15, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "sRGBx", + "value" : 16, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "sRGBA", + "value" : 17, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "sBGRA", + "value" : 18, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "ABGR", + "value" : 19, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "ImageChannelDataType", + "enumerants" : [ + { + "enumerant" : "SnormInt8", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "SnormInt16", + "value" : 1, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormInt8", + "value" : 2, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormInt16", + "value" : 3, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormShort565", + "value" : 4, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormShort555", + "value" : 5, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormInt101010", + "value" : 6, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "SignedInt8", + "value" : 7, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "SignedInt16", + "value" : 8, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "SignedInt32", + "value" : 9, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnsignedInt8", + "value" : 10, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnsignedInt16", + "value" : 11, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnsignedInt32", + "value" : 12, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "HalfFloat", + "value" : 13, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Float", + "value" : 14, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormInt24", + "value" : 15, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnormInt101010_2", + "value" : 16, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "FPRoundingMode", + "enumerants" : [ + { + "enumerant" : "RTE", + "value" : 0 + }, + { + "enumerant" : "RTZ", + "value" : 1 + }, + { + "enumerant" : "RTP", + "value" : 2 + }, + { + "enumerant" : "RTN", + "value" : 3 + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "LinkageType", + "enumerants" : [ + { + "enumerant" : "Export", + "value" : 0, + "capabilities" : [ "Linkage" ] + }, + { + "enumerant" : "Import", + "value" : 1, + "capabilities" : [ "Linkage" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "AccessQualifier", + "enumerants" : [ + { + "enumerant" : "ReadOnly", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "WriteOnly", + "value" : 1, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "ReadWrite", + "value" : 2, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "FunctionParameterAttribute", + "enumerants" : [ + { + "enumerant" : "Zext", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Sext", + "value" : 1, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "ByVal", + "value" : 2, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Sret", + "value" : 3, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NoAlias", + "value" : 4, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NoCapture", + "value" : 5, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NoWrite", + "value" : 6, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NoReadWrite", + "value" : 7, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "Decoration", + "enumerants" : [ + { + "enumerant" : "RelaxedPrecision", + "value" : 0, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SpecId", + "value" : 1, + "capabilities" : [ "Shader", "Kernel" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Specialization Constant ID'" } + ] + }, + { + "enumerant" : "Block", + "value" : 2, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "BufferBlock", + "value" : 3, + "capabilities" : [ "Shader" ], + "lastVersion" : "1.3" + }, + { + "enumerant" : "RowMajor", + "value" : 4, + "capabilities" : [ "Matrix" ] + }, + { + "enumerant" : "ColMajor", + "value" : 5, + "capabilities" : [ "Matrix" ] + }, + { + "enumerant" : "ArrayStride", + "value" : 6, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Array Stride'" } + ] + }, + { + "enumerant" : "MatrixStride", + "value" : 7, + "capabilities" : [ "Matrix" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Matrix Stride'" } + ] + }, + { + "enumerant" : "GLSLShared", + "value" : 8, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "GLSLPacked", + "value" : 9, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "CPacked", + "value" : 10, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "BuiltIn", + "value" : 11, + "parameters" : [ + { "kind" : "BuiltIn" } + ] + }, + { + "enumerant" : "NoPerspective", + "value" : 13, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Flat", + "value" : 14, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Patch", + "value" : 15, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "Centroid", + "value" : 16, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Sample", + "value" : 17, + "capabilities" : [ "SampleRateShading" ] + }, + { + "enumerant" : "Invariant", + "value" : 18, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Restrict", + "value" : 19 + }, + { + "enumerant" : "Aliased", + "value" : 20 + }, + { + "enumerant" : "Volatile", + "value" : 21 + }, + { + "enumerant" : "Constant", + "value" : 22, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Coherent", + "value" : 23 + }, + { + "enumerant" : "NonWritable", + "value" : 24 + }, + { + "enumerant" : "NonReadable", + "value" : 25 + }, + { + "enumerant" : "Uniform", + "value" : 26, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "UniformId", + "value" : 27, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "IdScope", "name" : "'Execution'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "SaturatedConversion", + "value" : 28, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Stream", + "value" : 29, + "capabilities" : [ "GeometryStreams" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Stream Number'" } + ] + }, + { + "enumerant" : "Location", + "value" : 30, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Location'" } + ] + }, + { + "enumerant" : "Component", + "value" : 31, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Component'" } + ] + }, + { + "enumerant" : "Index", + "value" : 32, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Index'" } + ] + }, + { + "enumerant" : "Binding", + "value" : 33, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Binding Point'" } + ] + }, + { + "enumerant" : "DescriptorSet", + "value" : 34, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Descriptor Set'" } + ] + }, + { + "enumerant" : "Offset", + "value" : 35, + "capabilities" : [ "Shader" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Byte Offset'" } + ] + }, + { + "enumerant" : "XfbBuffer", + "value" : 36, + "capabilities" : [ "TransformFeedback" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'XFB Buffer Number'" } + ] + }, + { + "enumerant" : "XfbStride", + "value" : 37, + "capabilities" : [ "TransformFeedback" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'XFB Stride'" } + ] + }, + { + "enumerant" : "FuncParamAttr", + "value" : 38, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "FunctionParameterAttribute", "name" : "'Function Parameter Attribute'" } + ] + }, + { + "enumerant" : "FPRoundingMode", + "value" : 39, + "parameters" : [ + { "kind" : "FPRoundingMode", "name" : "'Floating-Point Rounding Mode'" } + ] + }, + { + "enumerant" : "FPFastMathMode", + "value" : 40, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "FPFastMathMode", "name" : "'Fast-Math Mode'" } + ] + }, + { + "enumerant" : "LinkageAttributes", + "value" : 41, + "capabilities" : [ "Linkage" ], + "parameters" : [ + { "kind" : "LiteralString", "name" : "'Name'" }, + { "kind" : "LinkageType", "name" : "'Linkage Type'" } + ] + }, + { + "enumerant" : "NoContraction", + "value" : 42, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "InputAttachmentIndex", + "value" : 43, + "capabilities" : [ "InputAttachment" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Attachment Index'" } + ] + }, + { + "enumerant" : "Alignment", + "value" : 44, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Alignment'" } + ] + }, + { + "enumerant" : "MaxByteOffset", + "value" : 45, + "capabilities" : [ "Addresses" ], + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Max Byte Offset'" } + ], + "version" : "1.1" + }, + { + "enumerant" : "AlignmentId", + "value" : 46, + "capabilities" : [ "Kernel" ], + "parameters" : [ + { "kind" : "IdRef", "name" : "'Alignment'" } + ], + "version" : "1.2" + }, + { + "enumerant" : "MaxByteOffsetId", + "value" : 47, + "capabilities" : [ "Addresses" ], + "parameters" : [ + { "kind" : "IdRef", "name" : "'Max Byte Offset'" } + ], + "version" : "1.2" + }, + { + "enumerant" : "NoSignedWrap", + "value" : 4469, + "extensions" : [ "SPV_KHR_no_integer_wrap_decoration" ], + "version" : "1.4" + }, + { + "enumerant" : "NoUnsignedWrap", + "value" : 4470, + "extensions" : [ "SPV_KHR_no_integer_wrap_decoration" ], + "version" : "1.4" + }, + { + "enumerant" : "ExplicitInterpAMD", + "value" : 4999, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "OverrideCoverageNV", + "value" : 5248, + "capabilities" : [ "SampleMaskOverrideCoverageNV" ], + "extensions" : [ "SPV_NV_sample_mask_override_coverage" ], + "version" : "None" + }, + { + "enumerant" : "PassthroughNV", + "value" : 5250, + "capabilities" : [ "GeometryShaderPassthroughNV" ], + "extensions" : [ "SPV_NV_geometry_shader_passthrough" ], + "version" : "None" + }, + { + "enumerant" : "ViewportRelativeNV", + "value" : 5252, + "capabilities" : [ "ShaderViewportMaskNV" ], + "version" : "None" + }, + { + "enumerant" : "SecondaryViewportRelativeNV", + "value" : 5256, + "capabilities" : [ "ShaderStereoViewNV" ], + "extensions" : [ "SPV_NV_stereo_view_rendering" ], + "version" : "None", + "parameters" : [ + { "kind" : "LiteralInteger", "name" : "'Offset'" } + ] + }, + { + "enumerant" : "PerPrimitiveNV", + "value" : 5271, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "PerViewNV", + "value" : 5272, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "PerTaskNV", + "value" : 5273, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "PerVertexNV", + "value" : 5285, + "capabilities" : [ "FragmentBarycentricNV" ], + "extensions" : [ "SPV_NV_fragment_shader_barycentric" ], + "version" : "None" + }, + { + "enumerant" : "NonUniformEXT", + "value" : 5300, + "capabilities" : [ "ShaderNonUniformEXT" ] + }, + { + "enumerant" : "RestrictPointerEXT", + "value" : 5355, + "capabilities" : [ "PhysicalStorageBufferAddressesEXT" ], + "extensions" : [ "SPV_EXT_physical_storage_buffer" ], + "version" : "None" + }, + { + "enumerant" : "AliasedPointerEXT", + "value" : 5356, + "capabilities" : [ "PhysicalStorageBufferAddressesEXT" ], + "extensions" : [ "SPV_EXT_physical_storage_buffer" ], + "version" : "None" + }, + { + "enumerant" : "CounterBuffer", + "value" : 5634, + "parameters" : [ + { "kind" : "IdRef", "name" : "'Counter Buffer'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "HlslCounterBufferGOOGLE", + "value" : 5634, + "parameters" : [ + { "kind" : "IdRef", "name" : "'Counter Buffer'" } + ], + "extensions" : [ "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "None" + }, + { + "enumerant" : "UserSemantic", + "value" : 5635, + "parameters" : [ + { "kind" : "LiteralString", "name" : "'Semantic'" } + ], + "version" : "1.4" + }, + { + "enumerant" : "HlslSemanticGOOGLE", + "value" : 5635, + "parameters" : [ + { "kind" : "LiteralString", "name" : "'Semantic'" } + ], + "extensions" : [ "SPV_GOOGLE_hlsl_functionality1" ], + "version" : "None" + }, + { + "enumerant" : "UserTypeGOOGLE", + "value" : 5636, + "parameters" : [ + { "kind" : "LiteralString", "name" : "'User Type'" } + ], + "extensions" : [ "SPV_GOOGLE_user_type" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "BuiltIn", + "enumerants" : [ + { + "enumerant" : "Position", + "value" : 0, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "PointSize", + "value" : 1, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "ClipDistance", + "value" : 3, + "capabilities" : [ "ClipDistance" ] + }, + { + "enumerant" : "CullDistance", + "value" : 4, + "capabilities" : [ "CullDistance" ] + }, + { + "enumerant" : "VertexId", + "value" : 5, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "InstanceId", + "value" : 6, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "PrimitiveId", + "value" : 7, + "capabilities" : [ "Geometry", "Tessellation", "RayTracingNV" ] + }, + { + "enumerant" : "InvocationId", + "value" : 8, + "capabilities" : [ "Geometry", "Tessellation" ] + }, + { + "enumerant" : "Layer", + "value" : 9, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "ViewportIndex", + "value" : 10, + "capabilities" : [ "MultiViewport" ] + }, + { + "enumerant" : "TessLevelOuter", + "value" : 11, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "TessLevelInner", + "value" : 12, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "TessCoord", + "value" : 13, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "PatchVertices", + "value" : 14, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "FragCoord", + "value" : 15, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "PointCoord", + "value" : 16, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "FrontFacing", + "value" : 17, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SampleId", + "value" : 18, + "capabilities" : [ "SampleRateShading" ] + }, + { + "enumerant" : "SamplePosition", + "value" : 19, + "capabilities" : [ "SampleRateShading" ] + }, + { + "enumerant" : "SampleMask", + "value" : 20, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "FragDepth", + "value" : 22, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "HelperInvocation", + "value" : 23, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "NumWorkgroups", + "value" : 24 + }, + { + "enumerant" : "WorkgroupSize", + "value" : 25 + }, + { + "enumerant" : "WorkgroupId", + "value" : 26 + }, + { + "enumerant" : "LocalInvocationId", + "value" : 27 + }, + { + "enumerant" : "GlobalInvocationId", + "value" : 28 + }, + { + "enumerant" : "LocalInvocationIndex", + "value" : 29 + }, + { + "enumerant" : "WorkDim", + "value" : 30, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "GlobalSize", + "value" : 31, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "EnqueuedWorkgroupSize", + "value" : 32, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "GlobalOffset", + "value" : 33, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "GlobalLinearId", + "value" : 34, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "SubgroupSize", + "value" : 36, + "capabilities" : [ "Kernel", "GroupNonUniform", "SubgroupBallotKHR" ] + }, + { + "enumerant" : "SubgroupMaxSize", + "value" : 37, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "NumSubgroups", + "value" : 38, + "capabilities" : [ "Kernel", "GroupNonUniform" ] + }, + { + "enumerant" : "NumEnqueuedSubgroups", + "value" : 39, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "SubgroupId", + "value" : 40, + "capabilities" : [ "Kernel", "GroupNonUniform" ] + }, + { + "enumerant" : "SubgroupLocalInvocationId", + "value" : 41, + "capabilities" : [ "Kernel", "GroupNonUniform", "SubgroupBallotKHR" ] + }, + { + "enumerant" : "VertexIndex", + "value" : 42, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "InstanceIndex", + "value" : 43, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SubgroupEqMask", + "value" : 4416, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupGeMask", + "value" : 4417, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupGtMask", + "value" : 4418, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupLeMask", + "value" : 4419, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupLtMask", + "value" : 4420, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupEqMaskKHR", + "value" : 4416, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupGeMaskKHR", + "value" : 4417, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupGtMaskKHR", + "value" : 4418, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupLeMaskKHR", + "value" : 4419, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupLtMaskKHR", + "value" : 4420, + "capabilities" : [ "SubgroupBallotKHR", "GroupNonUniformBallot" ], + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "1.3" + }, + { + "enumerant" : "BaseVertex", + "value" : 4424, + "capabilities" : [ "DrawParameters" ], + "extensions" : [ "SPV_KHR_shader_draw_parameters" ], + "version" : "1.3" + }, + { + "enumerant" : "BaseInstance", + "value" : 4425, + "capabilities" : [ "DrawParameters" ], + "extensions" : [ "SPV_KHR_shader_draw_parameters" ], + "version" : "1.3" + }, + { + "enumerant" : "DrawIndex", + "value" : 4426, + "capabilities" : [ "DrawParameters", "MeshShadingNV" ], + "extensions" : [ "SPV_KHR_shader_draw_parameters", "SPV_NV_mesh_shader" ], + "version" : "1.3" + }, + { + "enumerant" : "DeviceIndex", + "value" : 4438, + "capabilities" : [ "DeviceGroup" ], + "extensions" : [ "SPV_KHR_device_group" ], + "version" : "1.3" + }, + { + "enumerant" : "ViewIndex", + "value" : 4440, + "capabilities" : [ "MultiView" ], + "extensions" : [ "SPV_KHR_multiview" ], + "version" : "1.3" + }, + { + "enumerant" : "BaryCoordNoPerspAMD", + "value" : 4992, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordNoPerspCentroidAMD", + "value" : 4993, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordNoPerspSampleAMD", + "value" : 4994, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordSmoothAMD", + "value" : 4995, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordSmoothCentroidAMD", + "value" : 4996, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordSmoothSampleAMD", + "value" : 4997, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordPullModelAMD", + "value" : 4998, + "extensions" : [ "SPV_AMD_shader_explicit_vertex_parameter" ], + "version" : "None" + }, + { + "enumerant" : "FragStencilRefEXT", + "value" : 5014, + "capabilities" : [ "StencilExportEXT" ], + "extensions" : [ "SPV_EXT_shader_stencil_export" ], + "version" : "None" + }, + { + "enumerant" : "ViewportMaskNV", + "value" : 5253, + "capabilities" : [ "ShaderViewportMaskNV", "MeshShadingNV" ], + "extensions" : [ "SPV_NV_viewport_array2", "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "SecondaryPositionNV", + "value" : 5257, + "capabilities" : [ "ShaderStereoViewNV" ], + "extensions" : [ "SPV_NV_stereo_view_rendering" ], + "version" : "None" + }, + { + "enumerant" : "SecondaryViewportMaskNV", + "value" : 5258, + "capabilities" : [ "ShaderStereoViewNV" ], + "extensions" : [ "SPV_NV_stereo_view_rendering" ], + "version" : "None" + }, + { + "enumerant" : "PositionPerViewNV", + "value" : 5261, + "capabilities" : [ "PerViewAttributesNV", "MeshShadingNV" ], + "extensions" : [ "SPV_NVX_multiview_per_view_attributes", "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "ViewportMaskPerViewNV", + "value" : 5262, + "capabilities" : [ "PerViewAttributesNV", "MeshShadingNV" ], + "extensions" : [ "SPV_NVX_multiview_per_view_attributes", "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "FullyCoveredEXT", + "value" : 5264, + "capabilities" : [ "FragmentFullyCoveredEXT" ], + "extensions" : [ "SPV_EXT_fragment_fully_covered" ], + "version" : "None" + }, + { + "enumerant" : "TaskCountNV", + "value" : 5274, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "PrimitiveCountNV", + "value" : 5275, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "PrimitiveIndicesNV", + "value" : 5276, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "ClipDistancePerViewNV", + "value" : 5277, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "CullDistancePerViewNV", + "value" : 5278, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "LayerPerViewNV", + "value" : 5279, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "MeshViewCountNV", + "value" : 5280, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "MeshViewIndicesNV", + "value" : 5281, + "capabilities" : [ "MeshShadingNV" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordNV", + "value" : 5286, + "capabilities" : [ "FragmentBarycentricNV" ], + "extensions" : [ "SPV_NV_fragment_shader_barycentric" ], + "version" : "None" + }, + { + "enumerant" : "BaryCoordNoPerspNV", + "value" : 5287, + "capabilities" : [ "FragmentBarycentricNV" ], + "extensions" : [ "SPV_NV_fragment_shader_barycentric" ], + "version" : "None" + }, + { + "enumerant" : "FragSizeEXT", + "value" : 5292 , + "capabilities" : [ "FragmentDensityEXT", "ShadingRateNV" ], + "extensions" : [ "SPV_EXT_fragment_invocation_density", "SPV_NV_shading_rate" ], + "version" : "None" + }, + { + "enumerant" : "FragmentSizeNV", + "value" : 5292 , + "capabilities" : [ "ShadingRateNV", "FragmentDensityEXT" ], + "extensions" : [ "SPV_NV_shading_rate", "SPV_EXT_fragment_invocation_density" ], + "version" : "None" + }, + { + "enumerant" : "FragInvocationCountEXT", + "value" : 5293, + "capabilities" : [ "FragmentDensityEXT", "ShadingRateNV" ], + "extensions" : [ "SPV_EXT_fragment_invocation_density", "SPV_NV_shading_rate" ], + "version" : "None" + }, + { + "enumerant" : "InvocationsPerPixelNV", + "value" : 5293, + "capabilities" : [ "ShadingRateNV", "FragmentDensityEXT" ], + "extensions" : [ "SPV_NV_shading_rate", "SPV_EXT_fragment_invocation_density" ], + "version" : "None" + }, + { + "enumerant" : "LaunchIdNV", + "value" : 5319, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "LaunchSizeNV", + "value" : 5320, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "WorldRayOriginNV", + "value" : 5321, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "WorldRayDirectionNV", + "value" : 5322, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "ObjectRayOriginNV", + "value" : 5323, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "ObjectRayDirectionNV", + "value" : 5324, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "RayTminNV", + "value" : 5325, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "RayTmaxNV", + "value" : 5326, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "InstanceCustomIndexNV", + "value" : 5327, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "ObjectToWorldNV", + "value" : 5330, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "WorldToObjectNV", + "value" : 5331, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "HitTNV", + "value" : 5332, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "HitKindNV", + "value" : 5333, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "IncomingRayFlagsNV", + "value" : 5351, + "capabilities" : [ "RayTracingNV" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "WarpsPerSMNV", + "value" : 5374, + "capabilities" : [ "ShaderSMBuiltinsNV" ], + "extensions" : [ "SPV_NV_shader_sm_builtins" ], + "version" : "None" + }, + { + "enumerant" : "SMCountNV", + "value" : 5375, + "capabilities" : [ "ShaderSMBuiltinsNV" ], + "extensions" : [ "SPV_NV_shader_sm_builtins" ], + "version" : "None" + }, + { + "enumerant" : "WarpIDNV", + "value" : 5376, + "capabilities" : [ "ShaderSMBuiltinsNV" ], + "extensions" : [ "SPV_NV_shader_sm_builtins" ], + "version" : "None" + }, + { + "enumerant" : "SMIDNV", + "value" : 5377, + "capabilities" : [ "ShaderSMBuiltinsNV" ], + "extensions" : [ "SPV_NV_shader_sm_builtins" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "Scope", + "enumerants" : [ + { + "enumerant" : "CrossDevice", + "value" : 0 + }, + { + "enumerant" : "Device", + "value" : 1 + }, + { + "enumerant" : "Workgroup", + "value" : 2 + }, + { + "enumerant" : "Subgroup", + "value" : 3 + }, + { + "enumerant" : "Invocation", + "value" : 4 + }, + { + "enumerant" : "QueueFamilyKHR", + "value" : 5, + "capabilities" : [ "VulkanMemoryModelKHR" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "GroupOperation", + "enumerants" : [ + { + "enumerant" : "Reduce", + "value" : 0, + "capabilities" : [ "Kernel", "GroupNonUniformArithmetic", "GroupNonUniformBallot" ] + }, + { + "enumerant" : "InclusiveScan", + "value" : 1, + "capabilities" : [ "Kernel", "GroupNonUniformArithmetic", "GroupNonUniformBallot" ] + }, + { + "enumerant" : "ExclusiveScan", + "value" : 2, + "capabilities" : [ "Kernel", "GroupNonUniformArithmetic", "GroupNonUniformBallot" ] + }, + { + "enumerant" : "ClusteredReduce", + "value" : 3, + "capabilities" : [ "GroupNonUniformClustered" ], + "version" : "1.3" + }, + { + "enumerant" : "PartitionedReduceNV", + "value" : 6, + "capabilities" : [ "GroupNonUniformPartitionedNV" ], + "extensions" : [ "SPV_NV_shader_subgroup_partitioned" ], + "version" : "None" + }, + { + "enumerant" : "PartitionedInclusiveScanNV", + "value" : 7, + "capabilities" : [ "GroupNonUniformPartitionedNV" ], + "extensions" : [ "SPV_NV_shader_subgroup_partitioned" ], + "version" : "None" + }, + { + "enumerant" : "PartitionedExclusiveScanNV", + "value" : 8, + "capabilities" : [ "GroupNonUniformPartitionedNV" ], + "extensions" : [ "SPV_NV_shader_subgroup_partitioned" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "KernelEnqueueFlags", + "enumerants" : [ + { + "enumerant" : "NoWait", + "value" : 0, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "WaitKernel", + "value" : 1, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "WaitWorkGroup", + "value" : 2, + "capabilities" : [ "Kernel" ] + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "Capability", + "enumerants" : [ + { + "enumerant" : "Matrix", + "value" : 0 + }, + { + "enumerant" : "Shader", + "value" : 1, + "capabilities" : [ "Matrix" ] + }, + { + "enumerant" : "Geometry", + "value" : 2, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Tessellation", + "value" : 3, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Addresses", + "value" : 4 + }, + { + "enumerant" : "Linkage", + "value" : 5 + }, + { + "enumerant" : "Kernel", + "value" : 6 + }, + { + "enumerant" : "Vector16", + "value" : 7, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Float16Buffer", + "value" : 8, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Float16", + "value" : 9 + }, + { + "enumerant" : "Float64", + "value" : 10 + }, + { + "enumerant" : "Int64", + "value" : 11 + }, + { + "enumerant" : "Int64Atomics", + "value" : 12, + "capabilities" : [ "Int64" ] + }, + { + "enumerant" : "ImageBasic", + "value" : 13, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "ImageReadWrite", + "value" : 14, + "capabilities" : [ "ImageBasic" ] + }, + { + "enumerant" : "ImageMipmap", + "value" : 15, + "capabilities" : [ "ImageBasic" ] + }, + { + "enumerant" : "Pipes", + "value" : 17, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "Groups", + "value" : 18, + "extensions" : [ "SPV_AMD_shader_ballot" ] + }, + { + "enumerant" : "DeviceEnqueue", + "value" : 19, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "LiteralSampler", + "value" : 20, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "AtomicStorage", + "value" : 21, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Int16", + "value" : 22 + }, + { + "enumerant" : "TessellationPointSize", + "value" : 23, + "capabilities" : [ "Tessellation" ] + }, + { + "enumerant" : "GeometryPointSize", + "value" : 24, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "ImageGatherExtended", + "value" : 25, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "StorageImageMultisample", + "value" : 27, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "UniformBufferArrayDynamicIndexing", + "value" : 28, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SampledImageArrayDynamicIndexing", + "value" : 29, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "StorageBufferArrayDynamicIndexing", + "value" : 30, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "StorageImageArrayDynamicIndexing", + "value" : 31, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "ClipDistance", + "value" : 32, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "CullDistance", + "value" : 33, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "ImageCubeArray", + "value" : 34, + "capabilities" : [ "SampledCubeArray" ] + }, + { + "enumerant" : "SampleRateShading", + "value" : 35, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "ImageRect", + "value" : 36, + "capabilities" : [ "SampledRect" ] + }, + { + "enumerant" : "SampledRect", + "value" : 37, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "GenericPointer", + "value" : 38, + "capabilities" : [ "Addresses" ] + }, + { + "enumerant" : "Int8", + "value" : 39 + }, + { + "enumerant" : "InputAttachment", + "value" : 40, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SparseResidency", + "value" : 41, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "MinLod", + "value" : 42, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "Sampled1D", + "value" : 43 + }, + { + "enumerant" : "Image1D", + "value" : 44, + "capabilities" : [ "Sampled1D" ] + }, + { + "enumerant" : "SampledCubeArray", + "value" : 45, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "SampledBuffer", + "value" : 46 + }, + { + "enumerant" : "ImageBuffer", + "value" : 47, + "capabilities" : [ "SampledBuffer" ] + }, + { + "enumerant" : "ImageMSArray", + "value" : 48, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "StorageImageExtendedFormats", + "value" : 49, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "ImageQuery", + "value" : 50, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "DerivativeControl", + "value" : 51, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "InterpolationFunction", + "value" : 52, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "TransformFeedback", + "value" : 53, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "GeometryStreams", + "value" : 54, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "StorageImageReadWithoutFormat", + "value" : 55, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "StorageImageWriteWithoutFormat", + "value" : 56, + "capabilities" : [ "Shader" ] + }, + { + "enumerant" : "MultiViewport", + "value" : 57, + "capabilities" : [ "Geometry" ] + }, + { + "enumerant" : "SubgroupDispatch", + "value" : 58, + "capabilities" : [ "DeviceEnqueue" ], + "version" : "1.1" + }, + { + "enumerant" : "NamedBarrier", + "value" : 59, + "capabilities" : [ "Kernel" ], + "version" : "1.1" + }, + { + "enumerant" : "PipeStorage", + "value" : 60, + "capabilities" : [ "Pipes" ], + "version" : "1.1" + }, + { + "enumerant" : "GroupNonUniform", + "value" : 61, + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformVote", + "value" : 62, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformArithmetic", + "value" : 63, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformBallot", + "value" : 64, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformShuffle", + "value" : 65, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformShuffleRelative", + "value" : 66, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformClustered", + "value" : 67, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "GroupNonUniformQuad", + "value" : 68, + "capabilities" : [ "GroupNonUniform" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupBallotKHR", + "value" : 4423, + "extensions" : [ "SPV_KHR_shader_ballot" ], + "version" : "None" + }, + { + "enumerant" : "DrawParameters", + "value" : 4427, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_KHR_shader_draw_parameters" ], + "version" : "1.3" + }, + { + "enumerant" : "SubgroupVoteKHR", + "value" : 4431, + "extensions" : [ "SPV_KHR_subgroup_vote" ], + "version" : "None" + }, + { + "enumerant" : "StorageBuffer16BitAccess", + "value" : 4433, + "extensions" : [ "SPV_KHR_16bit_storage" ], + "version" : "1.3" + }, + { + "enumerant" : "StorageUniformBufferBlock16", + "value" : 4433, + "extensions" : [ "SPV_KHR_16bit_storage" ], + "version" : "1.3" + }, + { + "enumerant" : "UniformAndStorageBuffer16BitAccess", + "value" : 4434, + "capabilities" : [ + "StorageBuffer16BitAccess", + "StorageUniformBufferBlock16" + ], + "extensions" : [ "SPV_KHR_16bit_storage" ], + "version" : "1.3" + }, + { + "enumerant" : "StorageUniform16", + "value" : 4434, + "capabilities" : [ + "StorageBuffer16BitAccess", + "StorageUniformBufferBlock16" + ], + "extensions" : [ "SPV_KHR_16bit_storage" ], + "version" : "1.3" + }, + { + "enumerant" : "StoragePushConstant16", + "value" : 4435, + "extensions" : [ "SPV_KHR_16bit_storage" ], + "version" : "1.3" + }, + { + "enumerant" : "StorageInputOutput16", + "value" : 4436, + "extensions" : [ "SPV_KHR_16bit_storage" ], + "version" : "1.3" + }, + { + "enumerant" : "DeviceGroup", + "value" : 4437, + "extensions" : [ "SPV_KHR_device_group" ], + "version" : "1.3" + }, + { + "enumerant" : "MultiView", + "value" : 4439, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_KHR_multiview" ], + "version" : "1.3" + }, + { + "enumerant" : "VariablePointersStorageBuffer", + "value" : 4441, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_KHR_variable_pointers" ], + "version" : "1.3" + }, + { + "enumerant" : "VariablePointers", + "value" : 4442, + "capabilities" : [ "VariablePointersStorageBuffer" ], + "extensions" : [ "SPV_KHR_variable_pointers" ], + "version" : "1.3" + }, + { + "enumerant" : "AtomicStorageOps", + "value" : 4445, + "extensions" : [ "SPV_KHR_shader_atomic_counter_ops" ], + "version" : "None" + }, + { + "enumerant" : "SampleMaskPostDepthCoverage", + "value" : 4447, + "extensions" : [ "SPV_KHR_post_depth_coverage" ], + "version" : "None" + }, + { + "enumerant" : "StorageBuffer8BitAccess", + "value" : 4448, + "extensions" : [ "SPV_KHR_8bit_storage" ], + "version" : "None" + }, + { + "enumerant" : "UniformAndStorageBuffer8BitAccess", + "value" : 4449, + "capabilities" : [ "StorageBuffer8BitAccess" ], + "extensions" : [ "SPV_KHR_8bit_storage" ], + "version" : "None" + }, + { + "enumerant" : "StoragePushConstant8", + "value" : 4450, + "extensions" : [ "SPV_KHR_8bit_storage" ], + "version" : "None" + }, + { + "enumerant" : "DenormPreserve", + "value" : 4464, + "extensions" : [ "SPV_KHR_float_controls" ], + "version" : "1.4" + }, + { + "enumerant" : "DenormFlushToZero", + "value" : 4465, + "extensions" : [ "SPV_KHR_float_controls" ], + "version" : "1.4" + }, + { + "enumerant" : "SignedZeroInfNanPreserve", + "value" : 4466, + "extensions" : [ "SPV_KHR_float_controls" ], + "version" : "1.4" + }, + { + "enumerant" : "RoundingModeRTE", + "value" : 4467, + "extensions" : [ "SPV_KHR_float_controls" ], + "version" : "1.4" + }, + { + "enumerant" : "RoundingModeRTZ", + "value" : 4468, + "extensions" : [ "SPV_KHR_float_controls" ], + "version" : "1.4" + }, + { + "enumerant" : "Float16ImageAMD", + "value" : 5008, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_AMD_gpu_shader_half_float_fetch" ], + "version" : "None" + }, + { + "enumerant" : "ImageGatherBiasLodAMD", + "value" : 5009, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_AMD_texture_gather_bias_lod" ], + "version" : "None" + }, + { + "enumerant" : "FragmentMaskAMD", + "value" : 5010, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_AMD_shader_fragment_mask" ], + "version" : "None" + }, + { + "enumerant" : "StencilExportEXT", + "value" : 5013, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_shader_stencil_export" ], + "version" : "None" + }, + { + "enumerant" : "ImageReadWriteLodAMD", + "value" : 5015, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_AMD_shader_image_load_store_lod" ], + "version" : "None" + }, + { + "enumerant" : "ShaderClockKHR", + "value" : 5055, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_KHR_shader_clock" ], + "version" : "None" + }, + { + "enumerant" : "SampleMaskOverrideCoverageNV", + "value" : 5249, + "capabilities" : [ "SampleRateShading" ], + "extensions" : [ "SPV_NV_sample_mask_override_coverage" ], + "version" : "None" + }, + { + "enumerant" : "GeometryShaderPassthroughNV", + "value" : 5251, + "capabilities" : [ "Geometry" ], + "extensions" : [ "SPV_NV_geometry_shader_passthrough" ], + "version" : "None" + }, + { + "enumerant" : "ShaderViewportIndexLayerEXT", + "value" : 5254, + "capabilities" : [ "MultiViewport" ], + "extensions" : [ "SPV_EXT_shader_viewport_index_layer" ], + "version" : "None" + }, + { + "enumerant" : "ShaderViewportIndexLayerNV", + "value" : 5254, + "capabilities" : [ "MultiViewport" ], + "extensions" : [ "SPV_NV_viewport_array2" ], + "version" : "None" + }, + { + "enumerant" : "ShaderViewportMaskNV", + "value" : 5255, + "capabilities" : [ "ShaderViewportIndexLayerNV" ], + "extensions" : [ "SPV_NV_viewport_array2" ], + "version" : "None" + }, + { + "enumerant" : "ShaderStereoViewNV", + "value" : 5259, + "capabilities" : [ "ShaderViewportMaskNV" ], + "extensions" : [ "SPV_NV_stereo_view_rendering" ], + "version" : "None" + }, + { + "enumerant" : "PerViewAttributesNV", + "value" : 5260, + "capabilities" : [ "MultiView" ], + "extensions" : [ "SPV_NVX_multiview_per_view_attributes" ], + "version" : "None" + }, + { + "enumerant" : "FragmentFullyCoveredEXT", + "value" : 5265, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_fragment_fully_covered" ], + "version" : "None" + }, + { + "enumerant" : "MeshShadingNV", + "value" : 5266, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_NV_mesh_shader" ], + "version" : "None" + }, + { + "enumerant" : "ImageFootprintNV", + "value" : 5282, + "extensions" : [ "SPV_NV_shader_image_footprint" ], + "version" : "None" + }, + { + "enumerant" : "FragmentBarycentricNV", + "value" : 5284, + "extensions" : [ "SPV_NV_fragment_shader_barycentric" ], + "version" : "None" + }, + { + "enumerant" : "ComputeDerivativeGroupQuadsNV", + "value" : 5288, + "extensions" : [ "SPV_NV_compute_shader_derivatives" ], + "version" : "None" + }, + { + "enumerant" : "FragmentDensityEXT", + "value" : 5291, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_fragment_invocation_density", "SPV_NV_shading_rate" ], + "version" : "None" + }, + { + "enumerant" : "ShadingRateNV", + "value" : 5291, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_NV_shading_rate", "SPV_EXT_fragment_invocation_density" ], + "version" : "None" + }, + { + "enumerant" : "GroupNonUniformPartitionedNV", + "value" : 5297, + "extensions" : [ "SPV_NV_shader_subgroup_partitioned" ], + "version" : "None" + }, + { + "enumerant" : "ShaderNonUniformEXT", + "value" : 5301, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "RuntimeDescriptorArrayEXT", + "value" : 5302, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "InputAttachmentArrayDynamicIndexingEXT", + "value" : 5303, + "capabilities" : [ "InputAttachment" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "UniformTexelBufferArrayDynamicIndexingEXT", + "value" : 5304, + "capabilities" : [ "SampledBuffer" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "StorageTexelBufferArrayDynamicIndexingEXT", + "value" : 5305, + "capabilities" : [ "ImageBuffer" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "UniformBufferArrayNonUniformIndexingEXT", + "value" : 5306, + "capabilities" : [ "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "SampledImageArrayNonUniformIndexingEXT", + "value" : 5307, + "capabilities" : [ "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "StorageBufferArrayNonUniformIndexingEXT", + "value" : 5308, + "capabilities" : [ "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "StorageImageArrayNonUniformIndexingEXT", + "value" : 5309, + "capabilities" : [ "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "InputAttachmentArrayNonUniformIndexingEXT", + "value" : 5310, + "capabilities" : [ "InputAttachment", "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "UniformTexelBufferArrayNonUniformIndexingEXT", + "value" : 5311, + "capabilities" : [ "SampledBuffer", "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "StorageTexelBufferArrayNonUniformIndexingEXT", + "value" : 5312, + "capabilities" : [ "ImageBuffer", "ShaderNonUniformEXT" ], + "extensions" : [ "SPV_EXT_descriptor_indexing" ], + "version" : "None" + }, + { + "enumerant" : "RayTracingNV", + "value" : 5340, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_NV_ray_tracing" ], + "version" : "None" + }, + { + "enumerant" : "VulkanMemoryModelKHR", + "value" : 5345, + "extensions" : [ "SPV_KHR_vulkan_memory_model" ], + "version" : "None" + }, + { + "enumerant" : "VulkanMemoryModelDeviceScopeKHR", + "value" : 5346, + "extensions" : [ "SPV_KHR_vulkan_memory_model" ], + "version" : "None" + }, + { + "enumerant" : "PhysicalStorageBufferAddressesEXT", + "value" : 5347, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_physical_storage_buffer" ], + "version" : "None" + }, + { + "enumerant" : "ComputeDerivativeGroupLinearNV", + "value" : 5350, + "extensions" : [ "SPV_NV_compute_shader_derivatives" ], + "version" : "None" + }, + { + "enumerant" : "CooperativeMatrixNV", + "value" : 5357, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_NV_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "FragmentShaderSampleInterlockEXT", + "value" : 5363, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "FragmentShaderShadingRateInterlockEXT", + "value" : 5372, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "ShaderSMBuiltinsNV", + "value" : 5373, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_NV_shader_sm_builtins" ], + "version" : "None" + }, + { + "enumerant" : "FragmentShaderPixelInterlockEXT", + "value" : 5378, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_fragment_shader_interlock" ], + "version" : "None" + }, + { + "enumerant" : "DemoteToHelperInvocationEXT", + "value" : 5379, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_EXT_demote_to_helper_invocation" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupShuffleINTEL", + "value" : 5568, + "extensions" : [ "SPV_INTEL_subgroups" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupBufferBlockIOINTEL", + "value" : 5569, + "extensions" : [ "SPV_INTEL_subgroups" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupImageBlockIOINTEL", + "value" : 5570, + "extensions" : [ "SPV_INTEL_subgroups" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupImageMediaBlockIOINTEL", + "value" : 5579, + "extensions" : [ "SPV_INTEL_media_block_io" ], + "version" : "None" + }, + { + "enumerant" : "IntegerFunctions2INTEL", + "value" : 5584, + "capabilities" : [ "Shader" ], + "extensions" : [ "SPV_INTEL_shader_integer_functions2" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupAvcMotionEstimationINTEL", + "value" : 5696, + "extensions" : [ "SPV_INTEL_device_side_avc_motion_estimation" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupAvcMotionEstimationIntraINTEL", + "value" : 5697, + "extensions" : [ "SPV_INTEL_device_side_avc_motion_estimation" ], + "version" : "None" + }, + { + "enumerant" : "SubgroupAvcMotionEstimationChromaINTEL", + "value" : 5698, + "extensions" : [ "SPV_INTEL_device_side_avc_motion_estimation" ], + "version" : "None" + } + ] + }, + { + "category" : "Id", + "kind" : "IdResultType", + "doc" : "Reference to an representing the result's type of the enclosing instruction" + }, + { + "category" : "Id", + "kind" : "IdResult", + "doc" : "Definition of an representing the result of the enclosing instruction" + }, + { + "category" : "Id", + "kind" : "IdMemorySemantics", + "doc" : "Reference to an representing a 32-bit integer that is a mask from the MemorySemantics operand kind" + }, + { + "category" : "Id", + "kind" : "IdScope", + "doc" : "Reference to an representing a 32-bit integer that is a mask from the Scope operand kind" + }, + { + "category" : "Id", + "kind" : "IdRef", + "doc" : "Reference to an " + }, + { + "category" : "Literal", + "kind" : "LiteralInteger", + "doc" : "An integer consuming one or more words" + }, + { + "category" : "Literal", + "kind" : "LiteralString", + "doc" : "A null-terminated stream of characters consuming an integral number of words" + }, + { + "category" : "Literal", + "kind" : "LiteralContextDependentNumber", + "doc" : "A literal number whose size and format are determined by a previous operand in the enclosing instruction" + }, + { + "category" : "Literal", + "kind" : "LiteralExtInstInteger", + "doc" : "A 32-bit unsigned integer indicating which instruction to use and determining the layout of following operands (for OpExtInst)" + }, + { + "category" : "Literal", + "kind" : "LiteralSpecConstantOpInteger", + "doc" : "An opcode indicating the operation to be performed and determining the layout of following operands (for OpSpecConstantOp)" + }, + { + "category" : "Composite", + "kind" : "PairLiteralIntegerIdRef", + "bases" : [ "LiteralInteger", "IdRef" ] + }, + { + "category" : "Composite", + "kind" : "PairIdRefLiteralInteger", + "bases" : [ "IdRef", "LiteralInteger" ] + }, + { + "category" : "Composite", + "kind" : "PairIdRefIdRef", + "bases" : [ "IdRef", "IdRef" ] + } + ] +} diff --git a/renderdoc/driver/shaders/spirv/spirv_common.h b/renderdoc/driver/shaders/spirv/spirv_common.h index 393dcce4f..609bfc24b 100644 --- a/renderdoc/driver/shaders/spirv/spirv_common.h +++ b/renderdoc/driver/shaders/spirv/spirv_common.h @@ -28,30 +28,13 @@ #include #include "3rdparty/glslang/SPIRV/spirv.hpp" #include "api/replay/renderdoc_replay.h" +#include "spirv_gen.h" namespace rdcspv { // length of 1 word in the top 16-bits, OpNop = 0 in the lower 16-bits static constexpr uint32_t OpNopWord = 0x00010000U; -struct Id -{ - constexpr inline Id() : id(0) {} - // only allow explicit functions to cast to/from uint32_t - constexpr static inline Id fromWord(uint32_t i) { return Id(i); } - inline uint32_t value() const { return id; } - constexpr inline explicit operator bool() const { return id != 0; } - constexpr inline bool operator==(const Id o) const { return id == o.id; } - constexpr inline bool operator!=(const Id o) const { return id != o.id; } - constexpr inline bool operator<(const Id o) const { return id < o.id; } - constexpr inline bool operator==(const uint32_t o) const { return id == o; } - constexpr inline bool operator!=(const uint32_t o) const { return id != o; } - constexpr inline bool operator<(const uint32_t o) const { return id < o; } -private: - constexpr inline Id(uint32_t i) : id(i) {} - uint32_t id; -}; - class Operation; template @@ -134,6 +117,8 @@ private: class Operation { public: + // temporary hack so the (unused) generated code will compile + Operation(rdcspv::Op op, const std::vector &data) : Operation((spv::Op)op, data) {} // constructor of a synthetic operation, from an operation & subsequent words, calculates the // length then constructs the first word with opcode + length. Operation(spv::Op op, const std::vector &data) diff --git a/renderdoc/driver/shaders/spirv/spirv_gen.cpp b/renderdoc/driver/shaders/spirv/spirv_gen.cpp new file mode 100644 index 000000000..607c37f4b --- /dev/null +++ b/renderdoc/driver/shaders/spirv/spirv_gen.cpp @@ -0,0 +1,8876 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2019 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +/****************************************************************************** + * Generated from Khronos SPIR-V machine-readable JSON grammar. + * + * Copyright (c) 2014-2016 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and/or associated documentation files (the "Materials"), + * to deal in the Materials without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Materials, and to permit persons to whom the + * Materials are furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Materials. + * + * MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS + * STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND + * HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS + * IN THE MATERIALS. + ******************************************************************************/ + +// This file is autogenerated with gen_spirv_code.py - any changes will be overwritten next time +// that script is run. +// $ ./gen_spirv_code.py + +// We need to disable clang-format since this file is programmatically generated +// clang-format off + +#include "spirv_gen.h" +#include "os/os_specific.h" +#include "spirv_op_helpers.h" + +template <> +rdcstr DoStringise(const rdcspv::ImageOperands &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::ImageOperands); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(Bias); + STRINGISE_BITFIELD_CLASS_BIT(Lod); + STRINGISE_BITFIELD_CLASS_BIT(Grad); + STRINGISE_BITFIELD_CLASS_BIT(ConstOffset); + STRINGISE_BITFIELD_CLASS_BIT(Offset); + STRINGISE_BITFIELD_CLASS_BIT(ConstOffsets); + STRINGISE_BITFIELD_CLASS_BIT(Sample); + STRINGISE_BITFIELD_CLASS_BIT(MinLod); + STRINGISE_BITFIELD_CLASS_BIT(MakeTexelAvailableKHR); + STRINGISE_BITFIELD_CLASS_BIT(MakeTexelVisibleKHR); + STRINGISE_BITFIELD_CLASS_BIT(NonPrivateTexelKHR); + STRINGISE_BITFIELD_CLASS_BIT(VolatileTexelKHR); + STRINGISE_BITFIELD_CLASS_BIT(SignExtend); + STRINGISE_BITFIELD_CLASS_BIT(ZeroExtend); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::FPFastMathMode &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::FPFastMathMode); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(NotNaN); + STRINGISE_BITFIELD_CLASS_BIT(NotInf); + STRINGISE_BITFIELD_CLASS_BIT(NSZ); + STRINGISE_BITFIELD_CLASS_BIT(AllowRecip); + STRINGISE_BITFIELD_CLASS_BIT(Fast); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::SelectionControl &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::SelectionControl); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(Flatten); + STRINGISE_BITFIELD_CLASS_BIT(DontFlatten); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::LoopControl &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::LoopControl); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(Unroll); + STRINGISE_BITFIELD_CLASS_BIT(DontUnroll); + STRINGISE_BITFIELD_CLASS_BIT(DependencyInfinite); + STRINGISE_BITFIELD_CLASS_BIT(DependencyLength); + STRINGISE_BITFIELD_CLASS_BIT(MinIterations); + STRINGISE_BITFIELD_CLASS_BIT(MaxIterations); + STRINGISE_BITFIELD_CLASS_BIT(IterationMultiple); + STRINGISE_BITFIELD_CLASS_BIT(PeelCount); + STRINGISE_BITFIELD_CLASS_BIT(PartialCount); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::FunctionControl &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::FunctionControl); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(Inline); + STRINGISE_BITFIELD_CLASS_BIT(DontInline); + STRINGISE_BITFIELD_CLASS_BIT(Pure); + STRINGISE_BITFIELD_CLASS_BIT(Const); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::MemorySemantics &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::MemorySemantics); + { + STRINGISE_BITFIELD_CLASS_BIT(Relaxed); + STRINGISE_BITFIELD_CLASS_BIT(Acquire); + STRINGISE_BITFIELD_CLASS_BIT(Release); + STRINGISE_BITFIELD_CLASS_BIT(AcquireRelease); + STRINGISE_BITFIELD_CLASS_BIT(SequentiallyConsistent); + STRINGISE_BITFIELD_CLASS_BIT(UniformMemory); + STRINGISE_BITFIELD_CLASS_BIT(SubgroupMemory); + STRINGISE_BITFIELD_CLASS_BIT(WorkgroupMemory); + STRINGISE_BITFIELD_CLASS_BIT(CrossWorkgroupMemory); + STRINGISE_BITFIELD_CLASS_BIT(AtomicCounterMemory); + STRINGISE_BITFIELD_CLASS_BIT(ImageMemory); + STRINGISE_BITFIELD_CLASS_BIT(OutputMemoryKHR); + STRINGISE_BITFIELD_CLASS_BIT(MakeAvailableKHR); + STRINGISE_BITFIELD_CLASS_BIT(MakeVisibleKHR); + STRINGISE_BITFIELD_CLASS_BIT(Volatile); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::MemoryAccess &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::MemoryAccess); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(Volatile); + STRINGISE_BITFIELD_CLASS_BIT(Aligned); + STRINGISE_BITFIELD_CLASS_BIT(Nontemporal); + STRINGISE_BITFIELD_CLASS_BIT(MakePointerAvailableKHR); + STRINGISE_BITFIELD_CLASS_BIT(MakePointerVisibleKHR); + STRINGISE_BITFIELD_CLASS_BIT(NonPrivatePointerKHR); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::KernelProfilingInfo &el) +{ + BEGIN_BITFIELD_STRINGISE(rdcspv::KernelProfilingInfo); + { + STRINGISE_BITFIELD_CLASS_VALUE(None); + + STRINGISE_BITFIELD_CLASS_BIT(CmdExecTime); + } + END_BITFIELD_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::SourceLanguage &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::SourceLanguage); + { + STRINGISE_ENUM_CLASS(Unknown); + STRINGISE_ENUM_CLASS(ESSL); + STRINGISE_ENUM_CLASS(GLSL); + STRINGISE_ENUM_CLASS(OpenCL_C); + STRINGISE_ENUM_CLASS(OpenCL_CPP); + STRINGISE_ENUM_CLASS(HLSL); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::ExecutionModel &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::ExecutionModel); + { + STRINGISE_ENUM_CLASS(Vertex); + STRINGISE_ENUM_CLASS(TessellationControl); + STRINGISE_ENUM_CLASS(TessellationEvaluation); + STRINGISE_ENUM_CLASS(Geometry); + STRINGISE_ENUM_CLASS(Fragment); + STRINGISE_ENUM_CLASS(GLCompute); + STRINGISE_ENUM_CLASS(Kernel); + STRINGISE_ENUM_CLASS(TaskNV); + STRINGISE_ENUM_CLASS(MeshNV); + STRINGISE_ENUM_CLASS(RayGenerationNV); + STRINGISE_ENUM_CLASS(IntersectionNV); + STRINGISE_ENUM_CLASS(AnyHitNV); + STRINGISE_ENUM_CLASS(ClosestHitNV); + STRINGISE_ENUM_CLASS(MissNV); + STRINGISE_ENUM_CLASS(CallableNV); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::AddressingModel &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::AddressingModel); + { + STRINGISE_ENUM_CLASS(Logical); + STRINGISE_ENUM_CLASS(Physical32); + STRINGISE_ENUM_CLASS(Physical64); + STRINGISE_ENUM_CLASS(PhysicalStorageBuffer64EXT); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::MemoryModel &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::MemoryModel); + { + STRINGISE_ENUM_CLASS(Simple); + STRINGISE_ENUM_CLASS(GLSL450); + STRINGISE_ENUM_CLASS(OpenCL); + STRINGISE_ENUM_CLASS(VulkanKHR); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::ExecutionMode &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::ExecutionMode); + { + STRINGISE_ENUM_CLASS(Invocations); + STRINGISE_ENUM_CLASS(SpacingEqual); + STRINGISE_ENUM_CLASS(SpacingFractionalEven); + STRINGISE_ENUM_CLASS(SpacingFractionalOdd); + STRINGISE_ENUM_CLASS(VertexOrderCw); + STRINGISE_ENUM_CLASS(VertexOrderCcw); + STRINGISE_ENUM_CLASS(PixelCenterInteger); + STRINGISE_ENUM_CLASS(OriginUpperLeft); + STRINGISE_ENUM_CLASS(OriginLowerLeft); + STRINGISE_ENUM_CLASS(EarlyFragmentTests); + STRINGISE_ENUM_CLASS(PointMode); + STRINGISE_ENUM_CLASS(Xfb); + STRINGISE_ENUM_CLASS(DepthReplacing); + STRINGISE_ENUM_CLASS(DepthGreater); + STRINGISE_ENUM_CLASS(DepthLess); + STRINGISE_ENUM_CLASS(DepthUnchanged); + STRINGISE_ENUM_CLASS(LocalSize); + STRINGISE_ENUM_CLASS(LocalSizeHint); + STRINGISE_ENUM_CLASS(InputPoints); + STRINGISE_ENUM_CLASS(InputLines); + STRINGISE_ENUM_CLASS(InputLinesAdjacency); + STRINGISE_ENUM_CLASS(Triangles); + STRINGISE_ENUM_CLASS(InputTrianglesAdjacency); + STRINGISE_ENUM_CLASS(Quads); + STRINGISE_ENUM_CLASS(Isolines); + STRINGISE_ENUM_CLASS(OutputVertices); + STRINGISE_ENUM_CLASS(OutputPoints); + STRINGISE_ENUM_CLASS(OutputLineStrip); + STRINGISE_ENUM_CLASS(OutputTriangleStrip); + STRINGISE_ENUM_CLASS(VecTypeHint); + STRINGISE_ENUM_CLASS(ContractionOff); + STRINGISE_ENUM_CLASS(Initializer); + STRINGISE_ENUM_CLASS(Finalizer); + STRINGISE_ENUM_CLASS(SubgroupSize); + STRINGISE_ENUM_CLASS(SubgroupsPerWorkgroup); + STRINGISE_ENUM_CLASS(SubgroupsPerWorkgroupId); + STRINGISE_ENUM_CLASS(LocalSizeId); + STRINGISE_ENUM_CLASS(LocalSizeHintId); + STRINGISE_ENUM_CLASS(PostDepthCoverage); + STRINGISE_ENUM_CLASS(DenormPreserve); + STRINGISE_ENUM_CLASS(DenormFlushToZero); + STRINGISE_ENUM_CLASS(SignedZeroInfNanPreserve); + STRINGISE_ENUM_CLASS(RoundingModeRTE); + STRINGISE_ENUM_CLASS(RoundingModeRTZ); + STRINGISE_ENUM_CLASS(StencilRefReplacingEXT); + STRINGISE_ENUM_CLASS(OutputLinesNV); + STRINGISE_ENUM_CLASS(OutputPrimitivesNV); + STRINGISE_ENUM_CLASS(DerivativeGroupQuadsNV); + STRINGISE_ENUM_CLASS(DerivativeGroupLinearNV); + STRINGISE_ENUM_CLASS(OutputTrianglesNV); + STRINGISE_ENUM_CLASS(PixelInterlockOrderedEXT); + STRINGISE_ENUM_CLASS(PixelInterlockUnorderedEXT); + STRINGISE_ENUM_CLASS(SampleInterlockOrderedEXT); + STRINGISE_ENUM_CLASS(SampleInterlockUnorderedEXT); + STRINGISE_ENUM_CLASS(ShadingRateInterlockOrderedEXT); + STRINGISE_ENUM_CLASS(ShadingRateInterlockUnorderedEXT); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::StorageClass &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::StorageClass); + { + STRINGISE_ENUM_CLASS(UniformConstant); + STRINGISE_ENUM_CLASS(Input); + STRINGISE_ENUM_CLASS(Uniform); + STRINGISE_ENUM_CLASS(Output); + STRINGISE_ENUM_CLASS(Workgroup); + STRINGISE_ENUM_CLASS(CrossWorkgroup); + STRINGISE_ENUM_CLASS(Private); + STRINGISE_ENUM_CLASS(Function); + STRINGISE_ENUM_CLASS(Generic); + STRINGISE_ENUM_CLASS(PushConstant); + STRINGISE_ENUM_CLASS(AtomicCounter); + STRINGISE_ENUM_CLASS(Image); + STRINGISE_ENUM_CLASS(StorageBuffer); + STRINGISE_ENUM_CLASS(CallableDataNV); + STRINGISE_ENUM_CLASS(IncomingCallableDataNV); + STRINGISE_ENUM_CLASS(RayPayloadNV); + STRINGISE_ENUM_CLASS(HitAttributeNV); + STRINGISE_ENUM_CLASS(IncomingRayPayloadNV); + STRINGISE_ENUM_CLASS(ShaderRecordBufferNV); + STRINGISE_ENUM_CLASS(PhysicalStorageBufferEXT); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::Dim &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::Dim); + { + STRINGISE_ENUM_CLASS_NAMED(_1D, "1D"); + STRINGISE_ENUM_CLASS_NAMED(_2D, "2D"); + STRINGISE_ENUM_CLASS_NAMED(_3D, "3D"); + STRINGISE_ENUM_CLASS(Cube); + STRINGISE_ENUM_CLASS(Rect); + STRINGISE_ENUM_CLASS(Buffer); + STRINGISE_ENUM_CLASS(SubpassData); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::SamplerAddressingMode &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::SamplerAddressingMode); + { + STRINGISE_ENUM_CLASS(None); + STRINGISE_ENUM_CLASS(ClampToEdge); + STRINGISE_ENUM_CLASS(Clamp); + STRINGISE_ENUM_CLASS(Repeat); + STRINGISE_ENUM_CLASS(RepeatMirrored); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::SamplerFilterMode &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::SamplerFilterMode); + { + STRINGISE_ENUM_CLASS(Nearest); + STRINGISE_ENUM_CLASS(Linear); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::ImageFormat &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::ImageFormat); + { + STRINGISE_ENUM_CLASS(Unknown); + STRINGISE_ENUM_CLASS(Rgba32f); + STRINGISE_ENUM_CLASS(Rgba16f); + STRINGISE_ENUM_CLASS(R32f); + STRINGISE_ENUM_CLASS(Rgba8); + STRINGISE_ENUM_CLASS(Rgba8Snorm); + STRINGISE_ENUM_CLASS(Rg32f); + STRINGISE_ENUM_CLASS(Rg16f); + STRINGISE_ENUM_CLASS(R11fG11fB10f); + STRINGISE_ENUM_CLASS(R16f); + STRINGISE_ENUM_CLASS(Rgba16); + STRINGISE_ENUM_CLASS(Rgb10A2); + STRINGISE_ENUM_CLASS(Rg16); + STRINGISE_ENUM_CLASS(Rg8); + STRINGISE_ENUM_CLASS(R16); + STRINGISE_ENUM_CLASS(R8); + STRINGISE_ENUM_CLASS(Rgba16Snorm); + STRINGISE_ENUM_CLASS(Rg16Snorm); + STRINGISE_ENUM_CLASS(Rg8Snorm); + STRINGISE_ENUM_CLASS(R16Snorm); + STRINGISE_ENUM_CLASS(R8Snorm); + STRINGISE_ENUM_CLASS(Rgba32i); + STRINGISE_ENUM_CLASS(Rgba16i); + STRINGISE_ENUM_CLASS(Rgba8i); + STRINGISE_ENUM_CLASS(R32i); + STRINGISE_ENUM_CLASS(Rg32i); + STRINGISE_ENUM_CLASS(Rg16i); + STRINGISE_ENUM_CLASS(Rg8i); + STRINGISE_ENUM_CLASS(R16i); + STRINGISE_ENUM_CLASS(R8i); + STRINGISE_ENUM_CLASS(Rgba32ui); + STRINGISE_ENUM_CLASS(Rgba16ui); + STRINGISE_ENUM_CLASS(Rgba8ui); + STRINGISE_ENUM_CLASS(R32ui); + STRINGISE_ENUM_CLASS(Rgb10a2ui); + STRINGISE_ENUM_CLASS(Rg32ui); + STRINGISE_ENUM_CLASS(Rg16ui); + STRINGISE_ENUM_CLASS(Rg8ui); + STRINGISE_ENUM_CLASS(R16ui); + STRINGISE_ENUM_CLASS(R8ui); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::ImageChannelOrder &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::ImageChannelOrder); + { + STRINGISE_ENUM_CLASS(R); + STRINGISE_ENUM_CLASS(A); + STRINGISE_ENUM_CLASS(RG); + STRINGISE_ENUM_CLASS(RA); + STRINGISE_ENUM_CLASS(RGB); + STRINGISE_ENUM_CLASS(RGBA); + STRINGISE_ENUM_CLASS(BGRA); + STRINGISE_ENUM_CLASS(ARGB); + STRINGISE_ENUM_CLASS(Intensity); + STRINGISE_ENUM_CLASS(Luminance); + STRINGISE_ENUM_CLASS(Rx); + STRINGISE_ENUM_CLASS(RGx); + STRINGISE_ENUM_CLASS(RGBx); + STRINGISE_ENUM_CLASS(Depth); + STRINGISE_ENUM_CLASS(DepthStencil); + STRINGISE_ENUM_CLASS(sRGB); + STRINGISE_ENUM_CLASS(sRGBx); + STRINGISE_ENUM_CLASS(sRGBA); + STRINGISE_ENUM_CLASS(sBGRA); + STRINGISE_ENUM_CLASS(ABGR); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::ImageChannelDataType &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::ImageChannelDataType); + { + STRINGISE_ENUM_CLASS(SnormInt8); + STRINGISE_ENUM_CLASS(SnormInt16); + STRINGISE_ENUM_CLASS(UnormInt8); + STRINGISE_ENUM_CLASS(UnormInt16); + STRINGISE_ENUM_CLASS(UnormShort565); + STRINGISE_ENUM_CLASS(UnormShort555); + STRINGISE_ENUM_CLASS(UnormInt101010); + STRINGISE_ENUM_CLASS(SignedInt8); + STRINGISE_ENUM_CLASS(SignedInt16); + STRINGISE_ENUM_CLASS(SignedInt32); + STRINGISE_ENUM_CLASS(UnsignedInt8); + STRINGISE_ENUM_CLASS(UnsignedInt16); + STRINGISE_ENUM_CLASS(UnsignedInt32); + STRINGISE_ENUM_CLASS(HalfFloat); + STRINGISE_ENUM_CLASS(Float); + STRINGISE_ENUM_CLASS(UnormInt24); + STRINGISE_ENUM_CLASS(UnormInt101010_2); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::FPRoundingMode &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::FPRoundingMode); + { + STRINGISE_ENUM_CLASS(RTE); + STRINGISE_ENUM_CLASS(RTZ); + STRINGISE_ENUM_CLASS(RTP); + STRINGISE_ENUM_CLASS(RTN); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::LinkageType &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::LinkageType); + { + STRINGISE_ENUM_CLASS(Export); + STRINGISE_ENUM_CLASS(Import); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::AccessQualifier &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::AccessQualifier); + { + STRINGISE_ENUM_CLASS(ReadOnly); + STRINGISE_ENUM_CLASS(WriteOnly); + STRINGISE_ENUM_CLASS(ReadWrite); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::FunctionParameterAttribute &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::FunctionParameterAttribute); + { + STRINGISE_ENUM_CLASS(Zext); + STRINGISE_ENUM_CLASS(Sext); + STRINGISE_ENUM_CLASS(ByVal); + STRINGISE_ENUM_CLASS(Sret); + STRINGISE_ENUM_CLASS(NoAlias); + STRINGISE_ENUM_CLASS(NoCapture); + STRINGISE_ENUM_CLASS(NoWrite); + STRINGISE_ENUM_CLASS(NoReadWrite); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::Decoration &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::Decoration); + { + STRINGISE_ENUM_CLASS(RelaxedPrecision); + STRINGISE_ENUM_CLASS(SpecId); + STRINGISE_ENUM_CLASS(Block); + STRINGISE_ENUM_CLASS(BufferBlock); + STRINGISE_ENUM_CLASS(RowMajor); + STRINGISE_ENUM_CLASS(ColMajor); + STRINGISE_ENUM_CLASS(ArrayStride); + STRINGISE_ENUM_CLASS(MatrixStride); + STRINGISE_ENUM_CLASS(GLSLShared); + STRINGISE_ENUM_CLASS(GLSLPacked); + STRINGISE_ENUM_CLASS(CPacked); + STRINGISE_ENUM_CLASS(BuiltIn); + STRINGISE_ENUM_CLASS(NoPerspective); + STRINGISE_ENUM_CLASS(Flat); + STRINGISE_ENUM_CLASS(Patch); + STRINGISE_ENUM_CLASS(Centroid); + STRINGISE_ENUM_CLASS(Sample); + STRINGISE_ENUM_CLASS(Invariant); + STRINGISE_ENUM_CLASS(Restrict); + STRINGISE_ENUM_CLASS(Aliased); + STRINGISE_ENUM_CLASS(Volatile); + STRINGISE_ENUM_CLASS(Constant); + STRINGISE_ENUM_CLASS(Coherent); + STRINGISE_ENUM_CLASS(NonWritable); + STRINGISE_ENUM_CLASS(NonReadable); + STRINGISE_ENUM_CLASS(Uniform); + STRINGISE_ENUM_CLASS(UniformId); + STRINGISE_ENUM_CLASS(SaturatedConversion); + STRINGISE_ENUM_CLASS(Stream); + STRINGISE_ENUM_CLASS(Location); + STRINGISE_ENUM_CLASS(Component); + STRINGISE_ENUM_CLASS(Index); + STRINGISE_ENUM_CLASS(Binding); + STRINGISE_ENUM_CLASS(DescriptorSet); + STRINGISE_ENUM_CLASS(Offset); + STRINGISE_ENUM_CLASS(XfbBuffer); + STRINGISE_ENUM_CLASS(XfbStride); + STRINGISE_ENUM_CLASS(FuncParamAttr); + STRINGISE_ENUM_CLASS(FPRoundingMode); + STRINGISE_ENUM_CLASS(FPFastMathMode); + STRINGISE_ENUM_CLASS(LinkageAttributes); + STRINGISE_ENUM_CLASS(NoContraction); + STRINGISE_ENUM_CLASS(InputAttachmentIndex); + STRINGISE_ENUM_CLASS(Alignment); + STRINGISE_ENUM_CLASS(MaxByteOffset); + STRINGISE_ENUM_CLASS(AlignmentId); + STRINGISE_ENUM_CLASS(MaxByteOffsetId); + STRINGISE_ENUM_CLASS(NoSignedWrap); + STRINGISE_ENUM_CLASS(NoUnsignedWrap); + STRINGISE_ENUM_CLASS(ExplicitInterpAMD); + STRINGISE_ENUM_CLASS(OverrideCoverageNV); + STRINGISE_ENUM_CLASS(PassthroughNV); + STRINGISE_ENUM_CLASS(ViewportRelativeNV); + STRINGISE_ENUM_CLASS(SecondaryViewportRelativeNV); + STRINGISE_ENUM_CLASS(PerPrimitiveNV); + STRINGISE_ENUM_CLASS(PerViewNV); + STRINGISE_ENUM_CLASS(PerTaskNV); + STRINGISE_ENUM_CLASS(PerVertexNV); + STRINGISE_ENUM_CLASS(NonUniformEXT); + STRINGISE_ENUM_CLASS(RestrictPointerEXT); + STRINGISE_ENUM_CLASS(AliasedPointerEXT); + STRINGISE_ENUM_CLASS(CounterBuffer); + STRINGISE_ENUM_CLASS(UserSemantic); + STRINGISE_ENUM_CLASS(UserTypeGOOGLE); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::BuiltIn &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::BuiltIn); + { + STRINGISE_ENUM_CLASS(Position); + STRINGISE_ENUM_CLASS(PointSize); + STRINGISE_ENUM_CLASS(ClipDistance); + STRINGISE_ENUM_CLASS(CullDistance); + STRINGISE_ENUM_CLASS(VertexId); + STRINGISE_ENUM_CLASS(InstanceId); + STRINGISE_ENUM_CLASS(PrimitiveId); + STRINGISE_ENUM_CLASS(InvocationId); + STRINGISE_ENUM_CLASS(Layer); + STRINGISE_ENUM_CLASS(ViewportIndex); + STRINGISE_ENUM_CLASS(TessLevelOuter); + STRINGISE_ENUM_CLASS(TessLevelInner); + STRINGISE_ENUM_CLASS(TessCoord); + STRINGISE_ENUM_CLASS(PatchVertices); + STRINGISE_ENUM_CLASS(FragCoord); + STRINGISE_ENUM_CLASS(PointCoord); + STRINGISE_ENUM_CLASS(FrontFacing); + STRINGISE_ENUM_CLASS(SampleId); + STRINGISE_ENUM_CLASS(SamplePosition); + STRINGISE_ENUM_CLASS(SampleMask); + STRINGISE_ENUM_CLASS(FragDepth); + STRINGISE_ENUM_CLASS(HelperInvocation); + STRINGISE_ENUM_CLASS(NumWorkgroups); + STRINGISE_ENUM_CLASS(WorkgroupSize); + STRINGISE_ENUM_CLASS(WorkgroupId); + STRINGISE_ENUM_CLASS(LocalInvocationId); + STRINGISE_ENUM_CLASS(GlobalInvocationId); + STRINGISE_ENUM_CLASS(LocalInvocationIndex); + STRINGISE_ENUM_CLASS(WorkDim); + STRINGISE_ENUM_CLASS(GlobalSize); + STRINGISE_ENUM_CLASS(EnqueuedWorkgroupSize); + STRINGISE_ENUM_CLASS(GlobalOffset); + STRINGISE_ENUM_CLASS(GlobalLinearId); + STRINGISE_ENUM_CLASS(SubgroupSize); + STRINGISE_ENUM_CLASS(SubgroupMaxSize); + STRINGISE_ENUM_CLASS(NumSubgroups); + STRINGISE_ENUM_CLASS(NumEnqueuedSubgroups); + STRINGISE_ENUM_CLASS(SubgroupId); + STRINGISE_ENUM_CLASS(SubgroupLocalInvocationId); + STRINGISE_ENUM_CLASS(VertexIndex); + STRINGISE_ENUM_CLASS(InstanceIndex); + STRINGISE_ENUM_CLASS(SubgroupEqMask); + STRINGISE_ENUM_CLASS(SubgroupGeMask); + STRINGISE_ENUM_CLASS(SubgroupGtMask); + STRINGISE_ENUM_CLASS(SubgroupLeMask); + STRINGISE_ENUM_CLASS(SubgroupLtMask); + STRINGISE_ENUM_CLASS(BaseVertex); + STRINGISE_ENUM_CLASS(BaseInstance); + STRINGISE_ENUM_CLASS(DrawIndex); + STRINGISE_ENUM_CLASS(DeviceIndex); + STRINGISE_ENUM_CLASS(ViewIndex); + STRINGISE_ENUM_CLASS(BaryCoordNoPerspAMD); + STRINGISE_ENUM_CLASS(BaryCoordNoPerspCentroidAMD); + STRINGISE_ENUM_CLASS(BaryCoordNoPerspSampleAMD); + STRINGISE_ENUM_CLASS(BaryCoordSmoothAMD); + STRINGISE_ENUM_CLASS(BaryCoordSmoothCentroidAMD); + STRINGISE_ENUM_CLASS(BaryCoordSmoothSampleAMD); + STRINGISE_ENUM_CLASS(BaryCoordPullModelAMD); + STRINGISE_ENUM_CLASS(FragStencilRefEXT); + STRINGISE_ENUM_CLASS(ViewportMaskNV); + STRINGISE_ENUM_CLASS(SecondaryPositionNV); + STRINGISE_ENUM_CLASS(SecondaryViewportMaskNV); + STRINGISE_ENUM_CLASS(PositionPerViewNV); + STRINGISE_ENUM_CLASS(ViewportMaskPerViewNV); + STRINGISE_ENUM_CLASS(FullyCoveredEXT); + STRINGISE_ENUM_CLASS(TaskCountNV); + STRINGISE_ENUM_CLASS(PrimitiveCountNV); + STRINGISE_ENUM_CLASS(PrimitiveIndicesNV); + STRINGISE_ENUM_CLASS(ClipDistancePerViewNV); + STRINGISE_ENUM_CLASS(CullDistancePerViewNV); + STRINGISE_ENUM_CLASS(LayerPerViewNV); + STRINGISE_ENUM_CLASS(MeshViewCountNV); + STRINGISE_ENUM_CLASS(MeshViewIndicesNV); + STRINGISE_ENUM_CLASS(BaryCoordNV); + STRINGISE_ENUM_CLASS(BaryCoordNoPerspNV); + STRINGISE_ENUM_CLASS(FragSizeEXT); + STRINGISE_ENUM_CLASS(FragInvocationCountEXT); + STRINGISE_ENUM_CLASS(LaunchIdNV); + STRINGISE_ENUM_CLASS(LaunchSizeNV); + STRINGISE_ENUM_CLASS(WorldRayOriginNV); + STRINGISE_ENUM_CLASS(WorldRayDirectionNV); + STRINGISE_ENUM_CLASS(ObjectRayOriginNV); + STRINGISE_ENUM_CLASS(ObjectRayDirectionNV); + STRINGISE_ENUM_CLASS(RayTminNV); + STRINGISE_ENUM_CLASS(RayTmaxNV); + STRINGISE_ENUM_CLASS(InstanceCustomIndexNV); + STRINGISE_ENUM_CLASS(ObjectToWorldNV); + STRINGISE_ENUM_CLASS(WorldToObjectNV); + STRINGISE_ENUM_CLASS(HitTNV); + STRINGISE_ENUM_CLASS(HitKindNV); + STRINGISE_ENUM_CLASS(IncomingRayFlagsNV); + STRINGISE_ENUM_CLASS(WarpsPerSMNV); + STRINGISE_ENUM_CLASS(SMCountNV); + STRINGISE_ENUM_CLASS(WarpIDNV); + STRINGISE_ENUM_CLASS(SMIDNV); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::Scope &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::Scope); + { + STRINGISE_ENUM_CLASS(CrossDevice); + STRINGISE_ENUM_CLASS(Device); + STRINGISE_ENUM_CLASS(Workgroup); + STRINGISE_ENUM_CLASS(Subgroup); + STRINGISE_ENUM_CLASS(Invocation); + STRINGISE_ENUM_CLASS(QueueFamilyKHR); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::GroupOperation &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::GroupOperation); + { + STRINGISE_ENUM_CLASS(Reduce); + STRINGISE_ENUM_CLASS(InclusiveScan); + STRINGISE_ENUM_CLASS(ExclusiveScan); + STRINGISE_ENUM_CLASS(ClusteredReduce); + STRINGISE_ENUM_CLASS(PartitionedReduceNV); + STRINGISE_ENUM_CLASS(PartitionedInclusiveScanNV); + STRINGISE_ENUM_CLASS(PartitionedExclusiveScanNV); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::KernelEnqueueFlags &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::KernelEnqueueFlags); + { + STRINGISE_ENUM_CLASS(NoWait); + STRINGISE_ENUM_CLASS(WaitKernel); + STRINGISE_ENUM_CLASS(WaitWorkGroup); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::Capability &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::Capability); + { + STRINGISE_ENUM_CLASS(Matrix); + STRINGISE_ENUM_CLASS(Shader); + STRINGISE_ENUM_CLASS(Geometry); + STRINGISE_ENUM_CLASS(Tessellation); + STRINGISE_ENUM_CLASS(Addresses); + STRINGISE_ENUM_CLASS(Linkage); + STRINGISE_ENUM_CLASS(Kernel); + STRINGISE_ENUM_CLASS(Vector16); + STRINGISE_ENUM_CLASS(Float16Buffer); + STRINGISE_ENUM_CLASS(Float16); + STRINGISE_ENUM_CLASS(Float64); + STRINGISE_ENUM_CLASS(Int64); + STRINGISE_ENUM_CLASS(Int64Atomics); + STRINGISE_ENUM_CLASS(ImageBasic); + STRINGISE_ENUM_CLASS(ImageReadWrite); + STRINGISE_ENUM_CLASS(ImageMipmap); + STRINGISE_ENUM_CLASS(Pipes); + STRINGISE_ENUM_CLASS(Groups); + STRINGISE_ENUM_CLASS(DeviceEnqueue); + STRINGISE_ENUM_CLASS(LiteralSampler); + STRINGISE_ENUM_CLASS(AtomicStorage); + STRINGISE_ENUM_CLASS(Int16); + STRINGISE_ENUM_CLASS(TessellationPointSize); + STRINGISE_ENUM_CLASS(GeometryPointSize); + STRINGISE_ENUM_CLASS(ImageGatherExtended); + STRINGISE_ENUM_CLASS(StorageImageMultisample); + STRINGISE_ENUM_CLASS(UniformBufferArrayDynamicIndexing); + STRINGISE_ENUM_CLASS(SampledImageArrayDynamicIndexing); + STRINGISE_ENUM_CLASS(StorageBufferArrayDynamicIndexing); + STRINGISE_ENUM_CLASS(StorageImageArrayDynamicIndexing); + STRINGISE_ENUM_CLASS(ClipDistance); + STRINGISE_ENUM_CLASS(CullDistance); + STRINGISE_ENUM_CLASS(ImageCubeArray); + STRINGISE_ENUM_CLASS(SampleRateShading); + STRINGISE_ENUM_CLASS(ImageRect); + STRINGISE_ENUM_CLASS(SampledRect); + STRINGISE_ENUM_CLASS(GenericPointer); + STRINGISE_ENUM_CLASS(Int8); + STRINGISE_ENUM_CLASS(InputAttachment); + STRINGISE_ENUM_CLASS(SparseResidency); + STRINGISE_ENUM_CLASS(MinLod); + STRINGISE_ENUM_CLASS(Sampled1D); + STRINGISE_ENUM_CLASS(Image1D); + STRINGISE_ENUM_CLASS(SampledCubeArray); + STRINGISE_ENUM_CLASS(SampledBuffer); + STRINGISE_ENUM_CLASS(ImageBuffer); + STRINGISE_ENUM_CLASS(ImageMSArray); + STRINGISE_ENUM_CLASS(StorageImageExtendedFormats); + STRINGISE_ENUM_CLASS(ImageQuery); + STRINGISE_ENUM_CLASS(DerivativeControl); + STRINGISE_ENUM_CLASS(InterpolationFunction); + STRINGISE_ENUM_CLASS(TransformFeedback); + STRINGISE_ENUM_CLASS(GeometryStreams); + STRINGISE_ENUM_CLASS(StorageImageReadWithoutFormat); + STRINGISE_ENUM_CLASS(StorageImageWriteWithoutFormat); + STRINGISE_ENUM_CLASS(MultiViewport); + STRINGISE_ENUM_CLASS(SubgroupDispatch); + STRINGISE_ENUM_CLASS(NamedBarrier); + STRINGISE_ENUM_CLASS(PipeStorage); + STRINGISE_ENUM_CLASS(GroupNonUniform); + STRINGISE_ENUM_CLASS(GroupNonUniformVote); + STRINGISE_ENUM_CLASS(GroupNonUniformArithmetic); + STRINGISE_ENUM_CLASS(GroupNonUniformBallot); + STRINGISE_ENUM_CLASS(GroupNonUniformShuffle); + STRINGISE_ENUM_CLASS(GroupNonUniformShuffleRelative); + STRINGISE_ENUM_CLASS(GroupNonUniformClustered); + STRINGISE_ENUM_CLASS(GroupNonUniformQuad); + STRINGISE_ENUM_CLASS(SubgroupBallotKHR); + STRINGISE_ENUM_CLASS(DrawParameters); + STRINGISE_ENUM_CLASS(SubgroupVoteKHR); + STRINGISE_ENUM_CLASS(StorageBuffer16BitAccess); + STRINGISE_ENUM_CLASS(UniformAndStorageBuffer16BitAccess); + STRINGISE_ENUM_CLASS(StoragePushConstant16); + STRINGISE_ENUM_CLASS(StorageInputOutput16); + STRINGISE_ENUM_CLASS(DeviceGroup); + STRINGISE_ENUM_CLASS(MultiView); + STRINGISE_ENUM_CLASS(VariablePointersStorageBuffer); + STRINGISE_ENUM_CLASS(VariablePointers); + STRINGISE_ENUM_CLASS(AtomicStorageOps); + STRINGISE_ENUM_CLASS(SampleMaskPostDepthCoverage); + STRINGISE_ENUM_CLASS(StorageBuffer8BitAccess); + STRINGISE_ENUM_CLASS(UniformAndStorageBuffer8BitAccess); + STRINGISE_ENUM_CLASS(StoragePushConstant8); + STRINGISE_ENUM_CLASS(DenormPreserve); + STRINGISE_ENUM_CLASS(DenormFlushToZero); + STRINGISE_ENUM_CLASS(SignedZeroInfNanPreserve); + STRINGISE_ENUM_CLASS(RoundingModeRTE); + STRINGISE_ENUM_CLASS(RoundingModeRTZ); + STRINGISE_ENUM_CLASS(Float16ImageAMD); + STRINGISE_ENUM_CLASS(ImageGatherBiasLodAMD); + STRINGISE_ENUM_CLASS(FragmentMaskAMD); + STRINGISE_ENUM_CLASS(StencilExportEXT); + STRINGISE_ENUM_CLASS(ImageReadWriteLodAMD); + STRINGISE_ENUM_CLASS(ShaderClockKHR); + STRINGISE_ENUM_CLASS(SampleMaskOverrideCoverageNV); + STRINGISE_ENUM_CLASS(GeometryShaderPassthroughNV); + STRINGISE_ENUM_CLASS(ShaderViewportIndexLayerEXT); + STRINGISE_ENUM_CLASS(ShaderViewportMaskNV); + STRINGISE_ENUM_CLASS(ShaderStereoViewNV); + STRINGISE_ENUM_CLASS(PerViewAttributesNV); + STRINGISE_ENUM_CLASS(FragmentFullyCoveredEXT); + STRINGISE_ENUM_CLASS(MeshShadingNV); + STRINGISE_ENUM_CLASS(ImageFootprintNV); + STRINGISE_ENUM_CLASS(FragmentBarycentricNV); + STRINGISE_ENUM_CLASS(ComputeDerivativeGroupQuadsNV); + STRINGISE_ENUM_CLASS(FragmentDensityEXT); + STRINGISE_ENUM_CLASS(GroupNonUniformPartitionedNV); + STRINGISE_ENUM_CLASS(ShaderNonUniformEXT); + STRINGISE_ENUM_CLASS(RuntimeDescriptorArrayEXT); + STRINGISE_ENUM_CLASS(InputAttachmentArrayDynamicIndexingEXT); + STRINGISE_ENUM_CLASS(UniformTexelBufferArrayDynamicIndexingEXT); + STRINGISE_ENUM_CLASS(StorageTexelBufferArrayDynamicIndexingEXT); + STRINGISE_ENUM_CLASS(UniformBufferArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(SampledImageArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(StorageBufferArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(StorageImageArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(InputAttachmentArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(UniformTexelBufferArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(StorageTexelBufferArrayNonUniformIndexingEXT); + STRINGISE_ENUM_CLASS(RayTracingNV); + STRINGISE_ENUM_CLASS(VulkanMemoryModelKHR); + STRINGISE_ENUM_CLASS(VulkanMemoryModelDeviceScopeKHR); + STRINGISE_ENUM_CLASS(PhysicalStorageBufferAddressesEXT); + STRINGISE_ENUM_CLASS(ComputeDerivativeGroupLinearNV); + STRINGISE_ENUM_CLASS(CooperativeMatrixNV); + STRINGISE_ENUM_CLASS(FragmentShaderSampleInterlockEXT); + STRINGISE_ENUM_CLASS(FragmentShaderShadingRateInterlockEXT); + STRINGISE_ENUM_CLASS(ShaderSMBuiltinsNV); + STRINGISE_ENUM_CLASS(FragmentShaderPixelInterlockEXT); + STRINGISE_ENUM_CLASS(DemoteToHelperInvocationEXT); + STRINGISE_ENUM_CLASS(SubgroupShuffleINTEL); + STRINGISE_ENUM_CLASS(SubgroupBufferBlockIOINTEL); + STRINGISE_ENUM_CLASS(SubgroupImageBlockIOINTEL); + STRINGISE_ENUM_CLASS(SubgroupImageMediaBlockIOINTEL); + STRINGISE_ENUM_CLASS(IntegerFunctions2INTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMotionEstimationINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMotionEstimationIntraINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMotionEstimationChromaINTEL); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::Op &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::Op); + { + STRINGISE_ENUM_CLASS(Nop); + STRINGISE_ENUM_CLASS(Undef); + STRINGISE_ENUM_CLASS(SourceContinued); + STRINGISE_ENUM_CLASS(Source); + STRINGISE_ENUM_CLASS(SourceExtension); + STRINGISE_ENUM_CLASS(Name); + STRINGISE_ENUM_CLASS(MemberName); + STRINGISE_ENUM_CLASS(String); + STRINGISE_ENUM_CLASS(Line); + STRINGISE_ENUM_CLASS(Extension); + STRINGISE_ENUM_CLASS(ExtInstImport); + STRINGISE_ENUM_CLASS(ExtInst); + STRINGISE_ENUM_CLASS(MemoryModel); + STRINGISE_ENUM_CLASS(EntryPoint); + STRINGISE_ENUM_CLASS(ExecutionMode); + STRINGISE_ENUM_CLASS(Capability); + STRINGISE_ENUM_CLASS(TypeVoid); + STRINGISE_ENUM_CLASS(TypeBool); + STRINGISE_ENUM_CLASS(TypeInt); + STRINGISE_ENUM_CLASS(TypeFloat); + STRINGISE_ENUM_CLASS(TypeVector); + STRINGISE_ENUM_CLASS(TypeMatrix); + STRINGISE_ENUM_CLASS(TypeImage); + STRINGISE_ENUM_CLASS(TypeSampler); + STRINGISE_ENUM_CLASS(TypeSampledImage); + STRINGISE_ENUM_CLASS(TypeArray); + STRINGISE_ENUM_CLASS(TypeRuntimeArray); + STRINGISE_ENUM_CLASS(TypeStruct); + STRINGISE_ENUM_CLASS(TypeOpaque); + STRINGISE_ENUM_CLASS(TypePointer); + STRINGISE_ENUM_CLASS(TypeFunction); + STRINGISE_ENUM_CLASS(TypeEvent); + STRINGISE_ENUM_CLASS(TypeDeviceEvent); + STRINGISE_ENUM_CLASS(TypeReserveId); + STRINGISE_ENUM_CLASS(TypeQueue); + STRINGISE_ENUM_CLASS(TypePipe); + STRINGISE_ENUM_CLASS(TypeForwardPointer); + STRINGISE_ENUM_CLASS(ConstantTrue); + STRINGISE_ENUM_CLASS(ConstantFalse); + STRINGISE_ENUM_CLASS(Constant); + STRINGISE_ENUM_CLASS(ConstantComposite); + STRINGISE_ENUM_CLASS(ConstantSampler); + STRINGISE_ENUM_CLASS(ConstantNull); + STRINGISE_ENUM_CLASS(SpecConstantTrue); + STRINGISE_ENUM_CLASS(SpecConstantFalse); + STRINGISE_ENUM_CLASS(SpecConstant); + STRINGISE_ENUM_CLASS(SpecConstantComposite); + STRINGISE_ENUM_CLASS(SpecConstantOp); + STRINGISE_ENUM_CLASS(Function); + STRINGISE_ENUM_CLASS(FunctionParameter); + STRINGISE_ENUM_CLASS(FunctionEnd); + STRINGISE_ENUM_CLASS(FunctionCall); + STRINGISE_ENUM_CLASS(Variable); + STRINGISE_ENUM_CLASS(ImageTexelPointer); + STRINGISE_ENUM_CLASS(Load); + STRINGISE_ENUM_CLASS(Store); + STRINGISE_ENUM_CLASS(CopyMemory); + STRINGISE_ENUM_CLASS(CopyMemorySized); + STRINGISE_ENUM_CLASS(AccessChain); + STRINGISE_ENUM_CLASS(InBoundsAccessChain); + STRINGISE_ENUM_CLASS(PtrAccessChain); + STRINGISE_ENUM_CLASS(ArrayLength); + STRINGISE_ENUM_CLASS(GenericPtrMemSemantics); + STRINGISE_ENUM_CLASS(InBoundsPtrAccessChain); + STRINGISE_ENUM_CLASS(Decorate); + STRINGISE_ENUM_CLASS(MemberDecorate); + STRINGISE_ENUM_CLASS(DecorationGroup); + STRINGISE_ENUM_CLASS(GroupDecorate); + STRINGISE_ENUM_CLASS(GroupMemberDecorate); + STRINGISE_ENUM_CLASS(VectorExtractDynamic); + STRINGISE_ENUM_CLASS(VectorInsertDynamic); + STRINGISE_ENUM_CLASS(VectorShuffle); + STRINGISE_ENUM_CLASS(CompositeConstruct); + STRINGISE_ENUM_CLASS(CompositeExtract); + STRINGISE_ENUM_CLASS(CompositeInsert); + STRINGISE_ENUM_CLASS(CopyObject); + STRINGISE_ENUM_CLASS(Transpose); + STRINGISE_ENUM_CLASS(SampledImage); + STRINGISE_ENUM_CLASS(ImageSampleImplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleExplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleDrefImplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleDrefExplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleProjImplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleProjExplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleProjDrefImplicitLod); + STRINGISE_ENUM_CLASS(ImageSampleProjDrefExplicitLod); + STRINGISE_ENUM_CLASS(ImageFetch); + STRINGISE_ENUM_CLASS(ImageGather); + STRINGISE_ENUM_CLASS(ImageDrefGather); + STRINGISE_ENUM_CLASS(ImageRead); + STRINGISE_ENUM_CLASS(ImageWrite); + STRINGISE_ENUM_CLASS(Image); + STRINGISE_ENUM_CLASS(ImageQueryFormat); + STRINGISE_ENUM_CLASS(ImageQueryOrder); + STRINGISE_ENUM_CLASS(ImageQuerySizeLod); + STRINGISE_ENUM_CLASS(ImageQuerySize); + STRINGISE_ENUM_CLASS(ImageQueryLod); + STRINGISE_ENUM_CLASS(ImageQueryLevels); + STRINGISE_ENUM_CLASS(ImageQuerySamples); + STRINGISE_ENUM_CLASS(ConvertFToU); + STRINGISE_ENUM_CLASS(ConvertFToS); + STRINGISE_ENUM_CLASS(ConvertSToF); + STRINGISE_ENUM_CLASS(ConvertUToF); + STRINGISE_ENUM_CLASS(UConvert); + STRINGISE_ENUM_CLASS(SConvert); + STRINGISE_ENUM_CLASS(FConvert); + STRINGISE_ENUM_CLASS(QuantizeToF16); + STRINGISE_ENUM_CLASS(ConvertPtrToU); + STRINGISE_ENUM_CLASS(SatConvertSToU); + STRINGISE_ENUM_CLASS(SatConvertUToS); + STRINGISE_ENUM_CLASS(ConvertUToPtr); + STRINGISE_ENUM_CLASS(PtrCastToGeneric); + STRINGISE_ENUM_CLASS(GenericCastToPtr); + STRINGISE_ENUM_CLASS(GenericCastToPtrExplicit); + STRINGISE_ENUM_CLASS(Bitcast); + STRINGISE_ENUM_CLASS(SNegate); + STRINGISE_ENUM_CLASS(FNegate); + STRINGISE_ENUM_CLASS(IAdd); + STRINGISE_ENUM_CLASS(FAdd); + STRINGISE_ENUM_CLASS(ISub); + STRINGISE_ENUM_CLASS(FSub); + STRINGISE_ENUM_CLASS(IMul); + STRINGISE_ENUM_CLASS(FMul); + STRINGISE_ENUM_CLASS(UDiv); + STRINGISE_ENUM_CLASS(SDiv); + STRINGISE_ENUM_CLASS(FDiv); + STRINGISE_ENUM_CLASS(UMod); + STRINGISE_ENUM_CLASS(SRem); + STRINGISE_ENUM_CLASS(SMod); + STRINGISE_ENUM_CLASS(FRem); + STRINGISE_ENUM_CLASS(FMod); + STRINGISE_ENUM_CLASS(VectorTimesScalar); + STRINGISE_ENUM_CLASS(MatrixTimesScalar); + STRINGISE_ENUM_CLASS(VectorTimesMatrix); + STRINGISE_ENUM_CLASS(MatrixTimesVector); + STRINGISE_ENUM_CLASS(MatrixTimesMatrix); + STRINGISE_ENUM_CLASS(OuterProduct); + STRINGISE_ENUM_CLASS(Dot); + STRINGISE_ENUM_CLASS(IAddCarry); + STRINGISE_ENUM_CLASS(ISubBorrow); + STRINGISE_ENUM_CLASS(UMulExtended); + STRINGISE_ENUM_CLASS(SMulExtended); + STRINGISE_ENUM_CLASS(Any); + STRINGISE_ENUM_CLASS(All); + STRINGISE_ENUM_CLASS(IsNan); + STRINGISE_ENUM_CLASS(IsInf); + STRINGISE_ENUM_CLASS(IsFinite); + STRINGISE_ENUM_CLASS(IsNormal); + STRINGISE_ENUM_CLASS(SignBitSet); + STRINGISE_ENUM_CLASS(LessOrGreater); + STRINGISE_ENUM_CLASS(Ordered); + STRINGISE_ENUM_CLASS(Unordered); + STRINGISE_ENUM_CLASS(LogicalEqual); + STRINGISE_ENUM_CLASS(LogicalNotEqual); + STRINGISE_ENUM_CLASS(LogicalOr); + STRINGISE_ENUM_CLASS(LogicalAnd); + STRINGISE_ENUM_CLASS(LogicalNot); + STRINGISE_ENUM_CLASS(Select); + STRINGISE_ENUM_CLASS(IEqual); + STRINGISE_ENUM_CLASS(INotEqual); + STRINGISE_ENUM_CLASS(UGreaterThan); + STRINGISE_ENUM_CLASS(SGreaterThan); + STRINGISE_ENUM_CLASS(UGreaterThanEqual); + STRINGISE_ENUM_CLASS(SGreaterThanEqual); + STRINGISE_ENUM_CLASS(ULessThan); + STRINGISE_ENUM_CLASS(SLessThan); + STRINGISE_ENUM_CLASS(ULessThanEqual); + STRINGISE_ENUM_CLASS(SLessThanEqual); + STRINGISE_ENUM_CLASS(FOrdEqual); + STRINGISE_ENUM_CLASS(FUnordEqual); + STRINGISE_ENUM_CLASS(FOrdNotEqual); + STRINGISE_ENUM_CLASS(FUnordNotEqual); + STRINGISE_ENUM_CLASS(FOrdLessThan); + STRINGISE_ENUM_CLASS(FUnordLessThan); + STRINGISE_ENUM_CLASS(FOrdGreaterThan); + STRINGISE_ENUM_CLASS(FUnordGreaterThan); + STRINGISE_ENUM_CLASS(FOrdLessThanEqual); + STRINGISE_ENUM_CLASS(FUnordLessThanEqual); + STRINGISE_ENUM_CLASS(FOrdGreaterThanEqual); + STRINGISE_ENUM_CLASS(FUnordGreaterThanEqual); + STRINGISE_ENUM_CLASS(ShiftRightLogical); + STRINGISE_ENUM_CLASS(ShiftRightArithmetic); + STRINGISE_ENUM_CLASS(ShiftLeftLogical); + STRINGISE_ENUM_CLASS(BitwiseOr); + STRINGISE_ENUM_CLASS(BitwiseXor); + STRINGISE_ENUM_CLASS(BitwiseAnd); + STRINGISE_ENUM_CLASS(Not); + STRINGISE_ENUM_CLASS(BitFieldInsert); + STRINGISE_ENUM_CLASS(BitFieldSExtract); + STRINGISE_ENUM_CLASS(BitFieldUExtract); + STRINGISE_ENUM_CLASS(BitReverse); + STRINGISE_ENUM_CLASS(BitCount); + STRINGISE_ENUM_CLASS(DPdx); + STRINGISE_ENUM_CLASS(DPdy); + STRINGISE_ENUM_CLASS(Fwidth); + STRINGISE_ENUM_CLASS(DPdxFine); + STRINGISE_ENUM_CLASS(DPdyFine); + STRINGISE_ENUM_CLASS(FwidthFine); + STRINGISE_ENUM_CLASS(DPdxCoarse); + STRINGISE_ENUM_CLASS(DPdyCoarse); + STRINGISE_ENUM_CLASS(FwidthCoarse); + STRINGISE_ENUM_CLASS(EmitVertex); + STRINGISE_ENUM_CLASS(EndPrimitive); + STRINGISE_ENUM_CLASS(EmitStreamVertex); + STRINGISE_ENUM_CLASS(EndStreamPrimitive); + STRINGISE_ENUM_CLASS(ControlBarrier); + STRINGISE_ENUM_CLASS(MemoryBarrier); + STRINGISE_ENUM_CLASS(AtomicLoad); + STRINGISE_ENUM_CLASS(AtomicStore); + STRINGISE_ENUM_CLASS(AtomicExchange); + STRINGISE_ENUM_CLASS(AtomicCompareExchange); + STRINGISE_ENUM_CLASS(AtomicCompareExchangeWeak); + STRINGISE_ENUM_CLASS(AtomicIIncrement); + STRINGISE_ENUM_CLASS(AtomicIDecrement); + STRINGISE_ENUM_CLASS(AtomicIAdd); + STRINGISE_ENUM_CLASS(AtomicISub); + STRINGISE_ENUM_CLASS(AtomicSMin); + STRINGISE_ENUM_CLASS(AtomicUMin); + STRINGISE_ENUM_CLASS(AtomicSMax); + STRINGISE_ENUM_CLASS(AtomicUMax); + STRINGISE_ENUM_CLASS(AtomicAnd); + STRINGISE_ENUM_CLASS(AtomicOr); + STRINGISE_ENUM_CLASS(AtomicXor); + STRINGISE_ENUM_CLASS(Phi); + STRINGISE_ENUM_CLASS(LoopMerge); + STRINGISE_ENUM_CLASS(SelectionMerge); + STRINGISE_ENUM_CLASS(Label); + STRINGISE_ENUM_CLASS(Branch); + STRINGISE_ENUM_CLASS(BranchConditional); + STRINGISE_ENUM_CLASS(Switch); + STRINGISE_ENUM_CLASS(Kill); + STRINGISE_ENUM_CLASS(Return); + STRINGISE_ENUM_CLASS(ReturnValue); + STRINGISE_ENUM_CLASS(Unreachable); + STRINGISE_ENUM_CLASS(LifetimeStart); + STRINGISE_ENUM_CLASS(LifetimeStop); + STRINGISE_ENUM_CLASS(GroupAsyncCopy); + STRINGISE_ENUM_CLASS(GroupWaitEvents); + STRINGISE_ENUM_CLASS(GroupAll); + STRINGISE_ENUM_CLASS(GroupAny); + STRINGISE_ENUM_CLASS(GroupBroadcast); + STRINGISE_ENUM_CLASS(GroupIAdd); + STRINGISE_ENUM_CLASS(GroupFAdd); + STRINGISE_ENUM_CLASS(GroupFMin); + STRINGISE_ENUM_CLASS(GroupUMin); + STRINGISE_ENUM_CLASS(GroupSMin); + STRINGISE_ENUM_CLASS(GroupFMax); + STRINGISE_ENUM_CLASS(GroupUMax); + STRINGISE_ENUM_CLASS(GroupSMax); + STRINGISE_ENUM_CLASS(ReadPipe); + STRINGISE_ENUM_CLASS(WritePipe); + STRINGISE_ENUM_CLASS(ReservedReadPipe); + STRINGISE_ENUM_CLASS(ReservedWritePipe); + STRINGISE_ENUM_CLASS(ReserveReadPipePackets); + STRINGISE_ENUM_CLASS(ReserveWritePipePackets); + STRINGISE_ENUM_CLASS(CommitReadPipe); + STRINGISE_ENUM_CLASS(CommitWritePipe); + STRINGISE_ENUM_CLASS(IsValidReserveId); + STRINGISE_ENUM_CLASS(GetNumPipePackets); + STRINGISE_ENUM_CLASS(GetMaxPipePackets); + STRINGISE_ENUM_CLASS(GroupReserveReadPipePackets); + STRINGISE_ENUM_CLASS(GroupReserveWritePipePackets); + STRINGISE_ENUM_CLASS(GroupCommitReadPipe); + STRINGISE_ENUM_CLASS(GroupCommitWritePipe); + STRINGISE_ENUM_CLASS(EnqueueMarker); + STRINGISE_ENUM_CLASS(EnqueueKernel); + STRINGISE_ENUM_CLASS(GetKernelNDrangeSubGroupCount); + STRINGISE_ENUM_CLASS(GetKernelNDrangeMaxSubGroupSize); + STRINGISE_ENUM_CLASS(GetKernelWorkGroupSize); + STRINGISE_ENUM_CLASS(GetKernelPreferredWorkGroupSizeMultiple); + STRINGISE_ENUM_CLASS(RetainEvent); + STRINGISE_ENUM_CLASS(ReleaseEvent); + STRINGISE_ENUM_CLASS(CreateUserEvent); + STRINGISE_ENUM_CLASS(IsValidEvent); + STRINGISE_ENUM_CLASS(SetUserEventStatus); + STRINGISE_ENUM_CLASS(CaptureEventProfilingInfo); + STRINGISE_ENUM_CLASS(GetDefaultQueue); + STRINGISE_ENUM_CLASS(BuildNDRange); + STRINGISE_ENUM_CLASS(ImageSparseSampleImplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleExplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleDrefImplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleDrefExplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleProjImplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleProjExplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleProjDrefImplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseSampleProjDrefExplicitLod); + STRINGISE_ENUM_CLASS(ImageSparseFetch); + STRINGISE_ENUM_CLASS(ImageSparseGather); + STRINGISE_ENUM_CLASS(ImageSparseDrefGather); + STRINGISE_ENUM_CLASS(ImageSparseTexelsResident); + STRINGISE_ENUM_CLASS(NoLine); + STRINGISE_ENUM_CLASS(AtomicFlagTestAndSet); + STRINGISE_ENUM_CLASS(AtomicFlagClear); + STRINGISE_ENUM_CLASS(ImageSparseRead); + STRINGISE_ENUM_CLASS(SizeOf); + STRINGISE_ENUM_CLASS(TypePipeStorage); + STRINGISE_ENUM_CLASS(ConstantPipeStorage); + STRINGISE_ENUM_CLASS(CreatePipeFromPipeStorage); + STRINGISE_ENUM_CLASS(GetKernelLocalSizeForSubgroupCount); + STRINGISE_ENUM_CLASS(GetKernelMaxNumSubgroups); + STRINGISE_ENUM_CLASS(TypeNamedBarrier); + STRINGISE_ENUM_CLASS(NamedBarrierInitialize); + STRINGISE_ENUM_CLASS(MemoryNamedBarrier); + STRINGISE_ENUM_CLASS(ModuleProcessed); + STRINGISE_ENUM_CLASS(ExecutionModeId); + STRINGISE_ENUM_CLASS(DecorateId); + STRINGISE_ENUM_CLASS(GroupNonUniformElect); + STRINGISE_ENUM_CLASS(GroupNonUniformAll); + STRINGISE_ENUM_CLASS(GroupNonUniformAny); + STRINGISE_ENUM_CLASS(GroupNonUniformAllEqual); + STRINGISE_ENUM_CLASS(GroupNonUniformBroadcast); + STRINGISE_ENUM_CLASS(GroupNonUniformBroadcastFirst); + STRINGISE_ENUM_CLASS(GroupNonUniformBallot); + STRINGISE_ENUM_CLASS(GroupNonUniformInverseBallot); + STRINGISE_ENUM_CLASS(GroupNonUniformBallotBitExtract); + STRINGISE_ENUM_CLASS(GroupNonUniformBallotBitCount); + STRINGISE_ENUM_CLASS(GroupNonUniformBallotFindLSB); + STRINGISE_ENUM_CLASS(GroupNonUniformBallotFindMSB); + STRINGISE_ENUM_CLASS(GroupNonUniformShuffle); + STRINGISE_ENUM_CLASS(GroupNonUniformShuffleXor); + STRINGISE_ENUM_CLASS(GroupNonUniformShuffleUp); + STRINGISE_ENUM_CLASS(GroupNonUniformShuffleDown); + STRINGISE_ENUM_CLASS(GroupNonUniformIAdd); + STRINGISE_ENUM_CLASS(GroupNonUniformFAdd); + STRINGISE_ENUM_CLASS(GroupNonUniformIMul); + STRINGISE_ENUM_CLASS(GroupNonUniformFMul); + STRINGISE_ENUM_CLASS(GroupNonUniformSMin); + STRINGISE_ENUM_CLASS(GroupNonUniformUMin); + STRINGISE_ENUM_CLASS(GroupNonUniformFMin); + STRINGISE_ENUM_CLASS(GroupNonUniformSMax); + STRINGISE_ENUM_CLASS(GroupNonUniformUMax); + STRINGISE_ENUM_CLASS(GroupNonUniformFMax); + STRINGISE_ENUM_CLASS(GroupNonUniformBitwiseAnd); + STRINGISE_ENUM_CLASS(GroupNonUniformBitwiseOr); + STRINGISE_ENUM_CLASS(GroupNonUniformBitwiseXor); + STRINGISE_ENUM_CLASS(GroupNonUniformLogicalAnd); + STRINGISE_ENUM_CLASS(GroupNonUniformLogicalOr); + STRINGISE_ENUM_CLASS(GroupNonUniformLogicalXor); + STRINGISE_ENUM_CLASS(GroupNonUniformQuadBroadcast); + STRINGISE_ENUM_CLASS(GroupNonUniformQuadSwap); + STRINGISE_ENUM_CLASS(CopyLogical); + STRINGISE_ENUM_CLASS(PtrEqual); + STRINGISE_ENUM_CLASS(PtrNotEqual); + STRINGISE_ENUM_CLASS(PtrDiff); + STRINGISE_ENUM_CLASS(SubgroupBallotKHR); + STRINGISE_ENUM_CLASS(SubgroupFirstInvocationKHR); + STRINGISE_ENUM_CLASS(SubgroupAllKHR); + STRINGISE_ENUM_CLASS(SubgroupAnyKHR); + STRINGISE_ENUM_CLASS(SubgroupAllEqualKHR); + STRINGISE_ENUM_CLASS(SubgroupReadInvocationKHR); + STRINGISE_ENUM_CLASS(GroupIAddNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupFAddNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupFMinNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupUMinNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupSMinNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupFMaxNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupUMaxNonUniformAMD); + STRINGISE_ENUM_CLASS(GroupSMaxNonUniformAMD); + STRINGISE_ENUM_CLASS(FragmentMaskFetchAMD); + STRINGISE_ENUM_CLASS(FragmentFetchAMD); + STRINGISE_ENUM_CLASS(ReadClockKHR); + STRINGISE_ENUM_CLASS(ImageSampleFootprintNV); + STRINGISE_ENUM_CLASS(GroupNonUniformPartitionNV); + STRINGISE_ENUM_CLASS(WritePackedPrimitiveIndices4x8NV); + STRINGISE_ENUM_CLASS(ReportIntersectionNV); + STRINGISE_ENUM_CLASS(IgnoreIntersectionNV); + STRINGISE_ENUM_CLASS(TerminateRayNV); + STRINGISE_ENUM_CLASS(TraceNV); + STRINGISE_ENUM_CLASS(TypeAccelerationStructureNV); + STRINGISE_ENUM_CLASS(ExecuteCallableNV); + STRINGISE_ENUM_CLASS(TypeCooperativeMatrixNV); + STRINGISE_ENUM_CLASS(CooperativeMatrixLoadNV); + STRINGISE_ENUM_CLASS(CooperativeMatrixStoreNV); + STRINGISE_ENUM_CLASS(CooperativeMatrixMulAddNV); + STRINGISE_ENUM_CLASS(CooperativeMatrixLengthNV); + STRINGISE_ENUM_CLASS(BeginInvocationInterlockEXT); + STRINGISE_ENUM_CLASS(EndInvocationInterlockEXT); + STRINGISE_ENUM_CLASS(DemoteToHelperInvocationEXT); + STRINGISE_ENUM_CLASS(IsHelperInvocationEXT); + STRINGISE_ENUM_CLASS(SubgroupShuffleINTEL); + STRINGISE_ENUM_CLASS(SubgroupShuffleDownINTEL); + STRINGISE_ENUM_CLASS(SubgroupShuffleUpINTEL); + STRINGISE_ENUM_CLASS(SubgroupShuffleXorINTEL); + STRINGISE_ENUM_CLASS(SubgroupBlockReadINTEL); + STRINGISE_ENUM_CLASS(SubgroupBlockWriteINTEL); + STRINGISE_ENUM_CLASS(SubgroupImageBlockReadINTEL); + STRINGISE_ENUM_CLASS(SubgroupImageBlockWriteINTEL); + STRINGISE_ENUM_CLASS(SubgroupImageMediaBlockReadINTEL); + STRINGISE_ENUM_CLASS(SubgroupImageMediaBlockWriteINTEL); + STRINGISE_ENUM_CLASS(UCountLeadingZerosINTEL); + STRINGISE_ENUM_CLASS(UCountTrailingZerosINTEL); + STRINGISE_ENUM_CLASS(AbsISubINTEL); + STRINGISE_ENUM_CLASS(AbsUSubINTEL); + STRINGISE_ENUM_CLASS(IAddSatINTEL); + STRINGISE_ENUM_CLASS(UAddSatINTEL); + STRINGISE_ENUM_CLASS(IAverageINTEL); + STRINGISE_ENUM_CLASS(UAverageINTEL); + STRINGISE_ENUM_CLASS(IAverageRoundedINTEL); + STRINGISE_ENUM_CLASS(UAverageRoundedINTEL); + STRINGISE_ENUM_CLASS(ISubSatINTEL); + STRINGISE_ENUM_CLASS(USubSatINTEL); + STRINGISE_ENUM_CLASS(IMul32x16INTEL); + STRINGISE_ENUM_CLASS(UMul32x16INTEL); + STRINGISE_ENUM_CLASS(DecorateString); + STRINGISE_ENUM_CLASS(MemberDecorateString); + STRINGISE_ENUM_CLASS(VmeImageINTEL); + STRINGISE_ENUM_CLASS(TypeVmeImageINTEL); + STRINGISE_ENUM_CLASS(TypeAvcImePayloadINTEL); + STRINGISE_ENUM_CLASS(TypeAvcRefPayloadINTEL); + STRINGISE_ENUM_CLASS(TypeAvcSicPayloadINTEL); + STRINGISE_ENUM_CLASS(TypeAvcMcePayloadINTEL); + STRINGISE_ENUM_CLASS(TypeAvcMceResultINTEL); + STRINGISE_ENUM_CLASS(TypeAvcImeResultINTEL); + STRINGISE_ENUM_CLASS(TypeAvcImeResultSingleReferenceStreamoutINTEL); + STRINGISE_ENUM_CLASS(TypeAvcImeResultDualReferenceStreamoutINTEL); + STRINGISE_ENUM_CLASS(TypeAvcImeSingleReferenceStreaminINTEL); + STRINGISE_ENUM_CLASS(TypeAvcImeDualReferenceStreaminINTEL); + STRINGISE_ENUM_CLASS(TypeAvcRefResultINTEL); + STRINGISE_ENUM_CLASS(TypeAvcSicResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultInterShapePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetInterShapePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetInterDirectionPenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetMotionVectorCostFunctionINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetAcOnlyHaarINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceConvertToImePayloadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceConvertToImeResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceConvertToRefPayloadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceConvertToRefResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceConvertToSicPayloadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceConvertToSicResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetMotionVectorsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterDistortionsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetBestInterDistortionsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterMajorShapeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterMinorShapeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterDirectionsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterMotionVectorCountINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterReferenceIdsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeInitializeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeSetSingleReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeSetDualReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeRefWindowSizeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeAdjustRefOffsetINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeConvertToMcePayloadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeSetMaxMotionVectorCountINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeSetUnidirectionalMixDisableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeSetWeightedSadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithSingleReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithDualReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeConvertToMceResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetSingleReferenceStreaminINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetDualReferenceStreaminINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeStripSingleReferenceStreamoutINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeStripDualReferenceStreamoutINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetBorderReachedINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetTruncatedSearchIndicationINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcFmeInitializeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcBmeInitializeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefConvertToMcePayloadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefSetBidirectionalMixDisableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefSetBilinearFilterEnableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefEvaluateWithSingleReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefEvaluateWithDualReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefEvaluateWithMultiReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcRefConvertToMceResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicInitializeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicConfigureSkcINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicConfigureIpeLumaINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicConfigureIpeLumaChromaINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetMotionVectorMaskINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicConvertToMcePayloadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicSetIntraLumaShapePenaltyINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicSetBilinearFilterEnableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicSetSkcForwardTransformEnableINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicSetBlockBasedRawSkipSadINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicEvaluateIpeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicEvaluateWithSingleReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicEvaluateWithDualReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicEvaluateWithMultiReferenceINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicConvertToMceResultINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetIpeLumaShapeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetBestIpeLumaDistortionINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetBestIpeChromaDistortionINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetPackedIpeLumaModesINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetIpeChromaModeINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL); + STRINGISE_ENUM_CLASS(SubgroupAvcSicGetInterRawSadsINTEL); + } + END_ENUM_STRINGISE(); +} + +namespace rdcspv +{ + +template<> +std::string ParamToStr(const std::function &idName, const Id &el) +{ + return idName(el); +} + +template<> +std::string ParamToStr(const std::function &idName, const rdcstr &el) +{ + return "\"" + el + "\""; +} + +template<> +std::string ParamToStr(const std::function &idName, const PairLiteralIntegerIdRef &el) +{ + return StringFormat::Fmt("[%u, %s]", el.first, idName(el.second).c_str()); +} + +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefLiteralInteger &el) +{ + return StringFormat::Fmt("[%s, %u]", idName(el.first).c_str(), el.second); +} + +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefIdRef &el) +{ + return StringFormat::Fmt("[%s, %s]", idName(el.first).c_str(), idName(el.second).c_str()); +} + +template<> +std::string ParamToStr(const std::function &idName, const rdcspv::ImageOperandsAndParamDatas &el) +{ + rdcstr ret; + + if(el.flags & ImageOperands::None) + ret += "None" ", "; + if(el.flags & ImageOperands::Bias) + ret += "Bias" "(" + idName(el.bias) + ")" ", "; + if(el.flags & ImageOperands::Lod) + ret += "Lod" "(" + idName(el.lod) + ")" ", "; + if(el.flags & ImageOperands::Grad) + ret += "Grad" "(" + idName(el.grad.first) + ", " + idName(el.grad.second) + ")" ", "; + if(el.flags & ImageOperands::ConstOffset) + ret += "ConstOffset" "(" + idName(el.constOffset) + ")" ", "; + if(el.flags & ImageOperands::Offset) + ret += "Offset" "(" + idName(el.offset) + ")" ", "; + if(el.flags & ImageOperands::ConstOffsets) + ret += "ConstOffsets" "(" + idName(el.constOffsets) + ")" ", "; + if(el.flags & ImageOperands::Sample) + ret += "Sample" "(" + idName(el.sample) + ")" ", "; + if(el.flags & ImageOperands::MinLod) + ret += "MinLod" "(" + idName(el.minLod) + ")" ", "; + if(el.flags & ImageOperands::MakeTexelAvailableKHR) + ret += "MakeTexelAvailableKHR" "(" + idName(el.makeTexelAvailableKHR) + ")" ", "; + if(el.flags & ImageOperands::MakeTexelVisibleKHR) + ret += "MakeTexelVisibleKHR" "(" + idName(el.makeTexelVisibleKHR) + ")" ", "; + if(el.flags & ImageOperands::NonPrivateTexelKHR) + ret += "NonPrivateTexelKHR" ", "; + if(el.flags & ImageOperands::VolatileTexelKHR) + ret += "VolatileTexelKHR" ", "; + if(el.flags & ImageOperands::SignExtend) + ret += "SignExtend" ", "; + if(el.flags & ImageOperands::ZeroExtend) + ret += "ZeroExtend" ", "; + + // remove trailing ", " + if(ret.size() > 2) + ret.erase(ret.size()-2, 2); + + return ret; +} + +template<> +std::string ParamToStr(const std::function &idName, const rdcspv::LoopControlAndParamDatas &el) +{ + rdcstr ret; + + if(el.flags & LoopControl::None) + ret += "None" ", "; + if(el.flags & LoopControl::Unroll) + ret += "Unroll" ", "; + if(el.flags & LoopControl::DontUnroll) + ret += "DontUnroll" ", "; + if(el.flags & LoopControl::DependencyInfinite) + ret += "DependencyInfinite" ", "; + if(el.flags & LoopControl::DependencyLength) + ret += "DependencyLength" "(" + ToStr(el.dependencyLength) + ")" ", "; + if(el.flags & LoopControl::MinIterations) + ret += "MinIterations" "(" + ToStr(el.minIterations) + ")" ", "; + if(el.flags & LoopControl::MaxIterations) + ret += "MaxIterations" "(" + ToStr(el.maxIterations) + ")" ", "; + if(el.flags & LoopControl::IterationMultiple) + ret += "IterationMultiple" "(" + ToStr(el.iterationMultiple) + ")" ", "; + if(el.flags & LoopControl::PeelCount) + ret += "PeelCount" "(" + ToStr(el.peelCount) + ")" ", "; + if(el.flags & LoopControl::PartialCount) + ret += "PartialCount" "(" + ToStr(el.partialCount) + ")" ", "; + + // remove trailing ", " + if(ret.size() > 2) + ret.erase(ret.size()-2, 2); + + return ret; +} + +template<> +std::string ParamToStr(const std::function &idName, const rdcspv::MemoryAccessAndParamDatas &el) +{ + rdcstr ret; + + if(el.flags & MemoryAccess::None) + ret += "None" ", "; + if(el.flags & MemoryAccess::Volatile) + ret += "Volatile" ", "; + if(el.flags & MemoryAccess::Aligned) + ret += "Aligned" "(" + ToStr(el.aligned) + ")" ", "; + if(el.flags & MemoryAccess::Nontemporal) + ret += "Nontemporal" ", "; + if(el.flags & MemoryAccess::MakePointerAvailableKHR) + ret += "MakePointerAvailableKHR" "(" + idName(el.makePointerAvailableKHR) + ")" ", "; + if(el.flags & MemoryAccess::MakePointerVisibleKHR) + ret += "MakePointerVisibleKHR" "(" + idName(el.makePointerVisibleKHR) + ")" ", "; + if(el.flags & MemoryAccess::NonPrivatePointerKHR) + ret += "NonPrivatePointerKHR" ", "; + + // remove trailing ", " + if(ret.size() > 2) + ret.erase(ret.size()-2, 2); + + return ret; +} + +template<> +std::string ParamToStr(const std::function &idName, const rdcspv::ExecutionModeAndParamData &el) +{ + rdcstr ret = ToStr(el.value); + + switch(el.value) + { + case ExecutionMode::Invocations: + ret += "(" + ToStr(el.invocations) + ")"; break; + case ExecutionMode::LocalSize: + ret += "(" + ToStr(el.localSize.xsize) + ", " + ToStr(el.localSize.ysize) + ", " + ToStr(el.localSize.zsize) + ")"; break; + case ExecutionMode::LocalSizeHint: + ret += "(" + ToStr(el.localSizeHint.xsize) + ", " + ToStr(el.localSizeHint.ysize) + ", " + ToStr(el.localSizeHint.zsize) + ")"; break; + case ExecutionMode::OutputVertices: + ret += "(" + ToStr(el.outputVertices) + ")"; break; + case ExecutionMode::VecTypeHint: + ret += "(" + ToStr(el.vecTypeHint) + ")"; break; + case ExecutionMode::SubgroupSize: + ret += "(" + ToStr(el.subgroupSize) + ")"; break; + case ExecutionMode::SubgroupsPerWorkgroup: + ret += "(" + ToStr(el.subgroupsPerWorkgroup) + ")"; break; + case ExecutionMode::SubgroupsPerWorkgroupId: + ret += "(" + idName(el.subgroupsPerWorkgroupId) + ")"; break; + case ExecutionMode::LocalSizeId: + ret += "(" + idName(el.localSizeId.xsize) + ", " + idName(el.localSizeId.ysize) + ", " + idName(el.localSizeId.zsize) + ")"; break; + case ExecutionMode::LocalSizeHintId: + ret += "(" + idName(el.localSizeHintId) + ")"; break; + case ExecutionMode::DenormPreserve: + ret += "(" + ToStr(el.denormPreserve) + ")"; break; + case ExecutionMode::DenormFlushToZero: + ret += "(" + ToStr(el.denormFlushToZero) + ")"; break; + case ExecutionMode::SignedZeroInfNanPreserve: + ret += "(" + ToStr(el.signedZeroInfNanPreserve) + ")"; break; + case ExecutionMode::RoundingModeRTE: + ret += "(" + ToStr(el.roundingModeRTE) + ")"; break; + case ExecutionMode::RoundingModeRTZ: + ret += "(" + ToStr(el.roundingModeRTZ) + ")"; break; + case ExecutionMode::OutputPrimitivesNV: + ret += "(" + ToStr(el.outputPrimitivesNV) + ")"; break; + default: + break; + } + + return ret; +} + +template<> +std::string ParamToStr(const std::function &idName, const rdcspv::DecorationAndParamData &el) +{ + rdcstr ret = ToStr(el.value); + + switch(el.value) + { + case Decoration::SpecId: + ret += "(" + ToStr(el.specId) + ")"; break; + case Decoration::ArrayStride: + ret += "(" + ToStr(el.arrayStride) + ")"; break; + case Decoration::MatrixStride: + ret += "(" + ToStr(el.matrixStride) + ")"; break; + case Decoration::BuiltIn: + ret += "(" + ToStr(el.builtIn) + ")"; break; + case Decoration::UniformId: + ret += "(" + idName(el.uniformId) + ")"; break; + case Decoration::Stream: + ret += "(" + ToStr(el.stream) + ")"; break; + case Decoration::Location: + ret += "(" + ToStr(el.location) + ")"; break; + case Decoration::Component: + ret += "(" + ToStr(el.component) + ")"; break; + case Decoration::Index: + ret += "(" + ToStr(el.index) + ")"; break; + case Decoration::Binding: + ret += "(" + ToStr(el.binding) + ")"; break; + case Decoration::DescriptorSet: + ret += "(" + ToStr(el.descriptorSet) + ")"; break; + case Decoration::Offset: + ret += "(" + ToStr(el.offset) + ")"; break; + case Decoration::XfbBuffer: + ret += "(" + ToStr(el.xfbBuffer) + ")"; break; + case Decoration::XfbStride: + ret += "(" + ToStr(el.xfbStride) + ")"; break; + case Decoration::FuncParamAttr: + ret += "(" + ToStr(el.funcParamAttr) + ")"; break; + case Decoration::FPRoundingMode: + ret += "(" + ToStr(el.fPRoundingMode) + ")"; break; + case Decoration::FPFastMathMode: + ret += "(" + ToStr(el.fPFastMathMode) + ")"; break; + case Decoration::InputAttachmentIndex: + ret += "(" + ToStr(el.inputAttachmentIndex) + ")"; break; + case Decoration::Alignment: + ret += "(" + ToStr(el.alignment) + ")"; break; + case Decoration::MaxByteOffset: + ret += "(" + ToStr(el.maxByteOffset) + ")"; break; + case Decoration::AlignmentId: + ret += "(" + idName(el.alignmentId) + ")"; break; + case Decoration::MaxByteOffsetId: + ret += "(" + idName(el.maxByteOffsetId) + ")"; break; + case Decoration::SecondaryViewportRelativeNV: + ret += "(" + ToStr(el.secondaryViewportRelativeNV) + ")"; break; + case Decoration::CounterBuffer: + ret += "(" + idName(el.counterBuffer) + ")"; break; + default: + break; + } + + return ret; +} + +void OpDecoder::AddUsedIDs(std::set &usedids, const ConstIter &it) +{ + switch((rdcspv::Op)it.opcode()) + { + case rdcspv::Op::Nop: + break; + case rdcspv::Op::Undef: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SourceContinued: + break; + case rdcspv::Op::Source: + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SourceExtension: + break; + case rdcspv::Op::Name: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::MemberName: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::String: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::Line: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::Extension: + break; + case rdcspv::Op::ExtInstImport: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::ExtInst: + break; + case rdcspv::Op::MemoryModel: + break; + case rdcspv::Op::EntryPoint: + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ExecutionMode: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::Capability: + break; + case rdcspv::Op::TypeVoid: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeBool: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeInt: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeFloat: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeVector: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeMatrix: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeImage: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeSampler: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeSampledImage: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeArray: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::TypeRuntimeArray: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeStruct: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeOpaque: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypePointer: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::TypeFunction: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::TypeEvent: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeDeviceEvent: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeReserveId: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeQueue: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypePipe: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeForwardPointer: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::ConstantTrue: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::ConstantFalse: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::Constant: + break; + case rdcspv::Op::ConstantComposite: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConstantSampler: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::ConstantNull: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SpecConstantTrue: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SpecConstantFalse: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SpecConstant: + break; + case rdcspv::Op::SpecConstantComposite: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SpecConstantOp: + break; + case rdcspv::Op::Function: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FunctionParameter: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::FunctionEnd: + break; + case rdcspv::Op::FunctionCall: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::Variable: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageTexelPointer: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::Load: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Store: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::CopyMemory: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::CopyMemorySized: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::AccessChain: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::InBoundsAccessChain: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::PtrAccessChain: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ArrayLength: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GenericPtrMemSemantics: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::InBoundsPtrAccessChain: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::Decorate: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::MemberDecorate: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::DecorationGroup: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::GroupDecorate: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::GroupMemberDecorate: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::VectorExtractDynamic: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::VectorInsertDynamic: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::VectorShuffle: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::CompositeConstruct: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::CompositeExtract: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::CompositeInsert: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::CopyObject: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Transpose: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SampledImage: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSampleImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSampleExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSampleDrefImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSampleDrefExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSampleProjImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSampleProjExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSampleProjDrefImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSampleProjDrefExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageFetch: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageGather: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageDrefGather: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageRead: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageWrite: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Image: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageQueryFormat: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageQueryOrder: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageQuerySizeLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageQuerySize: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageQueryLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageQueryLevels: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageQuerySamples: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConvertFToU: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConvertFToS: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConvertSToF: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConvertUToF: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::UConvert: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SConvert: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::FConvert: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::QuantizeToF16: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConvertPtrToU: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SatConvertSToU: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SatConvertUToS: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ConvertUToPtr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::PtrCastToGeneric: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GenericCastToPtr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GenericCastToPtrExplicit: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Bitcast: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SNegate: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::FNegate: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::IAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ISub: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FSub: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IMul: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FMul: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UDiv: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SDiv: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FDiv: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UMod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SRem: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SMod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FRem: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FMod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::VectorTimesScalar: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::MatrixTimesScalar: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::VectorTimesMatrix: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::MatrixTimesVector: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::MatrixTimesMatrix: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::OuterProduct: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::Dot: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IAddCarry: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ISubBorrow: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UMulExtended: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SMulExtended: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::Any: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::All: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::IsNan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::IsInf: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::IsFinite: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::IsNormal: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SignBitSet: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::LessOrGreater: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::Ordered: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::Unordered: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::LogicalEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::LogicalNotEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::LogicalOr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::LogicalAnd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::LogicalNot: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Select: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::IEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::INotEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UGreaterThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SGreaterThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UGreaterThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SGreaterThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ULessThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SLessThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ULessThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SLessThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FOrdEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FUnordEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FOrdNotEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FUnordNotEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FOrdLessThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FUnordLessThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FOrdGreaterThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FUnordGreaterThan: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FOrdLessThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FUnordLessThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FOrdGreaterThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FUnordGreaterThanEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ShiftRightLogical: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ShiftRightArithmetic: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ShiftLeftLogical: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::BitwiseOr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::BitwiseXor: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::BitwiseAnd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::Not: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::BitFieldInsert: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::BitFieldSExtract: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::BitFieldUExtract: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::BitReverse: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::BitCount: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::DPdx: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::DPdy: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Fwidth: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::DPdxFine: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::DPdyFine: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::FwidthFine: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::DPdxCoarse: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::DPdyCoarse: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::FwidthCoarse: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::EmitVertex: + break; + case rdcspv::Op::EndPrimitive: + break; + case rdcspv::Op::EmitStreamVertex: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::EndStreamPrimitive: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::ControlBarrier: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::MemoryBarrier: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::AtomicLoad: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::AtomicStore: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::AtomicExchange: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicCompareExchange: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + break; + case rdcspv::Op::AtomicCompareExchangeWeak: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + break; + case rdcspv::Op::AtomicIIncrement: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::AtomicIDecrement: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::AtomicIAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicISub: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicSMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicUMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicSMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicUMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicAnd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicOr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::AtomicXor: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::Phi: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::LoopMerge: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SelectionMerge: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::Label: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::Branch: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::BranchConditional: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::Switch: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::Kill: + break; + case rdcspv::Op::Return: + break; + case rdcspv::Op::ReturnValue: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::Unreachable: + break; + case rdcspv::Op::LifetimeStart: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::LifetimeStop: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::GroupAsyncCopy: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + break; + case rdcspv::Op::GroupWaitEvents: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GroupAll: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupAny: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupBroadcast: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupIAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupFAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupFMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupUMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupSMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupFMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupUMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupSMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ReadPipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::WritePipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::ReservedReadPipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + break; + case rdcspv::Op::ReservedWritePipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + break; + case rdcspv::Op::ReserveReadPipePackets: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::ReserveWritePipePackets: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::CommitReadPipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::CommitWritePipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IsValidReserveId: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GetNumPipePackets: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GetMaxPipePackets: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupReserveReadPipePackets: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::GroupReserveWritePipePackets: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::GroupCommitReadPipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupCommitWritePipe: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::EnqueueMarker: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::EnqueueKernel: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + usedids.insert(Id::fromWord(it.word(9))); + usedids.insert(Id::fromWord(it.word(10))); + usedids.insert(Id::fromWord(it.word(11))); + usedids.insert(Id::fromWord(it.word(12))); + usedids.insert(Id::fromWord(it.word(13))); + break; + case rdcspv::Op::GetKernelNDrangeSubGroupCount: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::GetKernelNDrangeMaxSubGroupSize: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::GetKernelWorkGroupSize: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GetKernelPreferredWorkGroupSizeMultiple: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::RetainEvent: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::ReleaseEvent: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::CreateUserEvent: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::IsValidEvent: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SetUserEventStatus: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::CaptureEventProfilingInfo: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GetDefaultQueue: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::BuildNDRange: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseSampleImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSparseSampleExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSparseSampleDrefImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseSampleDrefExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseSampleProjImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSparseSampleProjExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSparseSampleProjDrefImplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseSampleProjDrefExplicitLod: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseFetch: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ImageSparseGather: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseDrefGather: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ImageSparseTexelsResident: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::NoLine: + break; + case rdcspv::Op::AtomicFlagTestAndSet: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::AtomicFlagClear: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageSparseRead: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SizeOf: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::TypePipeStorage: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::ConstantPipeStorage: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::CreatePipeFromPipeStorage: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GetKernelLocalSizeForSubgroupCount: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::GetKernelMaxNumSubgroups: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::TypeNamedBarrier: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::NamedBarrierInitialize: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::MemoryNamedBarrier: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ModuleProcessed: + break; + case rdcspv::Op::ExecutionModeId: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::DecorateId: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::GroupNonUniformElect: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::GroupNonUniformAll: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformAny: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformAllEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformBroadcast: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformBroadcastFirst: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformBallot: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformInverseBallot: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformBallotBitExtract: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformBallotBitCount: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformBallotFindLSB: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformBallotFindMSB: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupNonUniformShuffle: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformShuffleXor: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformShuffleUp: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformShuffleDown: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformIAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformFAdd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformIMul: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformFMul: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformSMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformUMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformFMin: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformSMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformUMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformFMax: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformBitwiseAnd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformBitwiseOr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformBitwiseXor: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformLogicalAnd: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformLogicalOr: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformLogicalXor: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformQuadBroadcast: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupNonUniformQuadSwap: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::CopyLogical: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::PtrEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::PtrNotEqual: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::PtrDiff: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupBallotKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupFirstInvocationKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAllKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAnyKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAllEqualKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupReadInvocationKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::GroupIAddNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupFAddNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupFMinNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupUMinNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupSMinNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupFMaxNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupUMaxNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::GroupSMaxNonUniformAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::FragmentMaskFetchAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::FragmentFetchAMD: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::ReadClockKHR: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::ImageSampleFootprintNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::GroupNonUniformPartitionNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::WritePackedPrimitiveIndices4x8NV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::ReportIntersectionNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IgnoreIntersectionNV: + break; + case rdcspv::Op::TerminateRayNV: + break; + case rdcspv::Op::TraceNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + usedids.insert(Id::fromWord(it.word(9))); + usedids.insert(Id::fromWord(it.word(10))); + usedids.insert(Id::fromWord(it.word(11))); + break; + case rdcspv::Op::TypeAccelerationStructureNV: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::ExecuteCallableNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeCooperativeMatrixNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::CooperativeMatrixLoadNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::CooperativeMatrixStoreNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::CooperativeMatrixMulAddNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::CooperativeMatrixLengthNV: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::BeginInvocationInterlockEXT: + break; + case rdcspv::Op::EndInvocationInterlockEXT: + break; + case rdcspv::Op::DemoteToHelperInvocationEXT: + break; + case rdcspv::Op::IsHelperInvocationEXT: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupShuffleINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupShuffleDownINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupShuffleUpINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupShuffleXorINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupBlockReadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupBlockWriteINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupImageBlockReadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupImageBlockWriteINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupImageMediaBlockReadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupImageMediaBlockWriteINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::UCountLeadingZerosINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::UCountTrailingZerosINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::AbsISubINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::AbsUSubINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IAddSatINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UAddSatINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IAverageINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UAverageINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IAverageRoundedINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UAverageRoundedINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::ISubSatINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::USubSatINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::IMul32x16INTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::UMul32x16INTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::DecorateString: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::MemberDecorateString: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::VmeImageINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::TypeVmeImageINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::TypeAvcImePayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcRefPayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcSicPayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcMcePayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcMceResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcImeResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcImeResultSingleReferenceStreamoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcImeResultDualReferenceStreamoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcImeSingleReferenceStreaminINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcImeDualReferenceStreaminINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcRefResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::TypeAvcSicResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterShapePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceSetInterShapePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceSetInterDirectionPenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupAvcMceSetMotionVectorCostFunctionINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + break; + case rdcspv::Op::SubgroupAvcMceSetAcOnlyHaarINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcMceConvertToImePayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceConvertToImeResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceConvertToRefPayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceConvertToRefResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceConvertToSicPayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceConvertToSicResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetMotionVectorsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterDistortionsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetBestInterDistortionsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterMajorShapeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterMinorShapeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterDirectionsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterMotionVectorCountINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterReferenceIdsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeInitializeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeSetSingleReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeSetDualReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcImeRefWindowSizeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeAdjustRefOffsetINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcImeConvertToMcePayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeSetMaxMotionVectorCountINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeSetUnidirectionalMixDisableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeSetWeightedSadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + break; + case rdcspv::Op::SubgroupAvcImeConvertToMceResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeGetSingleReferenceStreaminINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeGetDualReferenceStreaminINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeStripSingleReferenceStreamoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeStripDualReferenceStreamoutINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcImeGetBorderReachedINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcImeGetTruncatedSearchIndicationINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcFmeInitializeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + usedids.insert(Id::fromWord(it.word(9))); + break; + case rdcspv::Op::SubgroupAvcBmeInitializeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + usedids.insert(Id::fromWord(it.word(9))); + usedids.insert(Id::fromWord(it.word(10))); + break; + case rdcspv::Op::SubgroupAvcRefConvertToMcePayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcRefSetBidirectionalMixDisableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcRefSetBilinearFilterEnableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithSingleReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithDualReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithMultiReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcRefConvertToMceResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicInitializeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicConfigureSkcINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + break; + case rdcspv::Op::SubgroupAvcSicConfigureIpeLumaINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + usedids.insert(Id::fromWord(it.word(9))); + usedids.insert(Id::fromWord(it.word(10))); + break; + case rdcspv::Op::SubgroupAvcSicConfigureIpeLumaChromaINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + usedids.insert(Id::fromWord(it.word(7))); + usedids.insert(Id::fromWord(it.word(8))); + usedids.insert(Id::fromWord(it.word(9))); + usedids.insert(Id::fromWord(it.word(10))); + usedids.insert(Id::fromWord(it.word(11))); + usedids.insert(Id::fromWord(it.word(12))); + usedids.insert(Id::fromWord(it.word(13))); + break; + case rdcspv::Op::SubgroupAvcSicGetMotionVectorMaskINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcSicConvertToMcePayloadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicSetIntraLumaShapePenaltyINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcSicSetBilinearFilterEnableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicSetSkcForwardTransformEnableINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcSicSetBlockBasedRawSkipSadINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcSicEvaluateIpeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithSingleReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithDualReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithMultiReferenceINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + usedids.insert(Id::fromWord(it.word(4))); + usedids.insert(Id::fromWord(it.word(5))); + usedids.insert(Id::fromWord(it.word(6))); + break; + case rdcspv::Op::SubgroupAvcSicConvertToMceResultINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetIpeLumaShapeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetBestIpeLumaDistortionINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetBestIpeChromaDistortionINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetPackedIpeLumaModesINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetIpeChromaModeINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case rdcspv::Op::SubgroupAvcSicGetInterRawSadsINTEL: + usedids.insert(Id::fromWord(it.word(1))); + usedids.insert(Id::fromWord(it.word(2))); + usedids.insert(Id::fromWord(it.word(3))); + break; + case Op::Max: break; + } +} + +std::string OpDecoder::Disassemble(const ConstIter &it, const std::function &declName, const std::function &idName, const std::function &constIntVal) +{ + std::string ret; + switch((rdcspv::Op)it.opcode()) + { + case rdcspv::Op::Nop: + { + OpNop decoded(it); + ret += "Nop(" ")"; + break; + } + case rdcspv::Op::Undef: + { + OpUndef decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Undef(" ")"; + break; + } + case rdcspv::Op::SourceContinued: + { + OpSourceContinued decoded(it); + ret += "SourceContinued(" + ParamToStr(idName, decoded.continuedSource) + ")"; + break; + } + case rdcspv::Op::Source: + { + OpSource decoded(it); + ret += "Source(" + ParamToStr(idName, decoded.sourceLanguage) + ", " + ParamToStr(idName, decoded.version) + ", " + ParamToStr(idName, decoded.file) + ", " + ParamToStr(idName, decoded.source) + ")"; + break; + } + case rdcspv::Op::SourceExtension: + { + OpSourceExtension decoded(it); + ret += "SourceExtension(" + ParamToStr(idName, decoded.extension) + ")"; + break; + } + case rdcspv::Op::Name: + { + OpName decoded(it); + ret += "Name(" + ParamToStr(idName, decoded.target) + ", " + ParamToStr(idName, decoded.name) + ")"; + break; + } + case rdcspv::Op::MemberName: + { + OpMemberName decoded(it); + ret += "MemberName(" + ParamToStr(idName, decoded.type) + ", " + ParamToStr(idName, decoded.member) + ", " + ParamToStr(idName, decoded.name) + ")"; + break; + } + case rdcspv::Op::String: + { + OpString decoded(it); + ret += idName(decoded.result) + " = "; + ret += "String(" + ParamToStr(idName, decoded.string) + ")"; + break; + } + case rdcspv::Op::Line: + { + OpLine decoded(it); + ret += "Line(" + ParamToStr(idName, decoded.file) + ", " + ParamToStr(idName, decoded.line) + ", " + ParamToStr(idName, decoded.column) + ")"; + break; + } + case rdcspv::Op::Extension: + { + OpExtension decoded(it); + ret += "Extension(" + ParamToStr(idName, decoded.name) + ")"; + break; + } + case rdcspv::Op::ExtInstImport: + { + OpExtInstImport decoded(it); + ret += idName(decoded.result) + " = "; + ret += "ExtInstImport(" + ParamToStr(idName, decoded.name) + ")"; + break; + } + case rdcspv::Op::ExtInst: + { + OpDecoder decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ExtInst(...)"; + break; + } + case rdcspv::Op::MemoryModel: + { + OpMemoryModel decoded(it); + ret += "MemoryModel(" + ParamToStr(idName, decoded.addressingModel) + ", " + ParamToStr(idName, decoded.memoryModel) + ")"; + break; + } + case rdcspv::Op::EntryPoint: + { + OpEntryPoint decoded(it); + ret += "EntryPoint(" + ParamToStr(idName, decoded.executionModel) + ", " + ParamToStr(idName, decoded.entryPoint) + ", " + ParamToStr(idName, decoded.name) + ", " + ParamsToStr(idName, decoded.iface) + ")"; + break; + } + case rdcspv::Op::ExecutionMode: + { + OpExecutionMode decoded(it); + ret += "ExecutionMode(" + ParamToStr(idName, decoded.entryPoint) + ", " + ParamToStr(idName, decoded.mode) + ")"; + break; + } + case rdcspv::Op::Capability: + { + OpCapability decoded(it); + ret += "Capability(" + ParamToStr(idName, decoded.capability) + ")"; + break; + } + case rdcspv::Op::TypeVoid: + { + OpTypeVoid decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeVoid(" ")"; + break; + } + case rdcspv::Op::TypeBool: + { + OpTypeBool decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeBool(" ")"; + break; + } + case rdcspv::Op::TypeInt: + { + OpTypeInt decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeInt(" + ParamToStr(idName, decoded.width) + ", " + ParamToStr(idName, decoded.signedness) + ")"; + break; + } + case rdcspv::Op::TypeFloat: + { + OpTypeFloat decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeFloat(" + ParamToStr(idName, decoded.width) + ")"; + break; + } + case rdcspv::Op::TypeVector: + { + OpTypeVector decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeVector(" + ParamToStr(idName, decoded.componentType) + ", " + ParamToStr(idName, decoded.componentCount) + ")"; + break; + } + case rdcspv::Op::TypeMatrix: + { + OpTypeMatrix decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeMatrix(" + ParamToStr(idName, decoded.columnType) + ", " + ParamToStr(idName, decoded.columnCount) + ")"; + break; + } + case rdcspv::Op::TypeImage: + { + OpTypeImage decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeImage(" + ParamToStr(idName, decoded.sampledType) + ", " + ParamToStr(idName, decoded.dim) + ", " + ParamToStr(idName, decoded.depth) + ", " + ParamToStr(idName, decoded.arrayed) + ", " + ParamToStr(idName, decoded.mS) + ", " + ParamToStr(idName, decoded.sampled) + ", " + ParamToStr(idName, decoded.imageFormat) + ", " + ParamToStr(idName, decoded.accessQualifier) + ")"; + break; + } + case rdcspv::Op::TypeSampler: + { + OpTypeSampler decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeSampler(" ")"; + break; + } + case rdcspv::Op::TypeSampledImage: + { + OpTypeSampledImage decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeSampledImage(" + ParamToStr(idName, decoded.imageType) + ")"; + break; + } + case rdcspv::Op::TypeArray: + { + OpTypeArray decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeArray(" + ParamToStr(idName, decoded.elementType) + ", " + ParamToStr(idName, decoded.length) + ")"; + break; + } + case rdcspv::Op::TypeRuntimeArray: + { + OpTypeRuntimeArray decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeRuntimeArray(" + ParamToStr(idName, decoded.elementType) + ")"; + break; + } + case rdcspv::Op::TypeStruct: + { + OpTypeStruct decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeStruct(" + ParamsToStr(idName, decoded.members) + ")"; + break; + } + case rdcspv::Op::TypeOpaque: + { + OpTypeOpaque decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeOpaque(" + ParamToStr(idName, decoded.thenameoftheopaquetype) + ")"; + break; + } + case rdcspv::Op::TypePointer: + { + OpTypePointer decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypePointer(" + ParamToStr(idName, decoded.storageClass) + ", " + ParamToStr(idName, decoded.type) + ")"; + break; + } + case rdcspv::Op::TypeFunction: + { + OpTypeFunction decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeFunction(" + ParamToStr(idName, decoded.returnType) + ", " + ParamsToStr(idName, decoded.parameters) + ")"; + break; + } + case rdcspv::Op::TypeEvent: + { + OpTypeEvent decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeEvent(" ")"; + break; + } + case rdcspv::Op::TypeDeviceEvent: + { + OpTypeDeviceEvent decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeDeviceEvent(" ")"; + break; + } + case rdcspv::Op::TypeReserveId: + { + OpTypeReserveId decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeReserveId(" ")"; + break; + } + case rdcspv::Op::TypeQueue: + { + OpTypeQueue decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeQueue(" ")"; + break; + } + case rdcspv::Op::TypePipe: + { + OpTypePipe decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypePipe(" + ParamToStr(idName, decoded.qualifier) + ")"; + break; + } + case rdcspv::Op::TypeForwardPointer: + { + OpTypeForwardPointer decoded(it); + ret += "TypeForwardPointer(" + ParamToStr(idName, decoded.pointerType) + ", " + ParamToStr(idName, decoded.storageClass) + ")"; + break; + } + case rdcspv::Op::ConstantTrue: + { + OpConstantTrue decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConstantTrue(" ")"; + break; + } + case rdcspv::Op::ConstantFalse: + { + OpConstantFalse decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConstantFalse(" ")"; + break; + } + case rdcspv::Op::Constant: + { + OpDecoder decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Constant(...)"; + break; + } + case rdcspv::Op::ConstantComposite: + { + OpConstantComposite decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConstantComposite(" + ParamsToStr(idName, decoded.constituents) + ")"; + break; + } + case rdcspv::Op::ConstantSampler: + { + OpConstantSampler decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConstantSampler(" + ParamToStr(idName, decoded.samplerAddressingMode) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.samplerFilterMode) + ")"; + break; + } + case rdcspv::Op::ConstantNull: + { + OpConstantNull decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConstantNull(" ")"; + break; + } + case rdcspv::Op::SpecConstantTrue: + { + OpSpecConstantTrue decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SpecConstantTrue(" ")"; + break; + } + case rdcspv::Op::SpecConstantFalse: + { + OpSpecConstantFalse decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SpecConstantFalse(" ")"; + break; + } + case rdcspv::Op::SpecConstant: + { + OpDecoder decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SpecConstant(...)"; + break; + } + case rdcspv::Op::SpecConstantComposite: + { + OpSpecConstantComposite decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SpecConstantComposite(" + ParamsToStr(idName, decoded.constituents) + ")"; + break; + } + case rdcspv::Op::SpecConstantOp: + { + OpDecoder decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SpecConstantOp(...)"; + break; + } + case rdcspv::Op::Function: + { + OpFunction decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Function(" + ParamToStr(idName, decoded.functionControl) + ", " + ParamToStr(idName, decoded.functionType) + ")"; + break; + } + case rdcspv::Op::FunctionParameter: + { + OpFunctionParameter decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FunctionParameter(" ")"; + break; + } + case rdcspv::Op::FunctionEnd: + { + OpFunctionEnd decoded(it); + ret += "FunctionEnd(" ")"; + break; + } + case rdcspv::Op::FunctionCall: + { + OpFunctionCall decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FunctionCall(" + ParamToStr(idName, decoded.function) + ", " + ParamsToStr(idName, decoded.arguments) + ")"; + break; + } + case rdcspv::Op::Variable: + { + OpVariable decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Variable(" + ParamToStr(idName, decoded.storageClass) + ", " + ParamToStr(idName, decoded.initializer) + ")"; + break; + } + case rdcspv::Op::ImageTexelPointer: + { + OpImageTexelPointer decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageTexelPointer(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.sample) + ")"; + break; + } + case rdcspv::Op::Load: + { + OpLoad decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Load(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.memoryAccess) + ")"; + break; + } + case rdcspv::Op::Store: + { + OpStore decoded(it); + ret += "Store(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.object) + ", " + ParamToStr(idName, decoded.memoryAccess) + ")"; + break; + } + case rdcspv::Op::CopyMemory: + { + OpCopyMemory decoded(it); + ret += "CopyMemory(" + ParamToStr(idName, decoded.target) + ", " + ParamToStr(idName, decoded.source) + ", " + ParamToStr(idName, decoded.memoryAccess0) + ", " + ParamToStr(idName, decoded.memoryAccess1) + ")"; + break; + } + case rdcspv::Op::CopyMemorySized: + { + OpCopyMemorySized decoded(it); + ret += "CopyMemorySized(" + ParamToStr(idName, decoded.target) + ", " + ParamToStr(idName, decoded.source) + ", " + ParamToStr(idName, decoded.size) + ", " + ParamToStr(idName, decoded.memoryAccess0) + ", " + ParamToStr(idName, decoded.memoryAccess1) + ")"; + break; + } + case rdcspv::Op::AccessChain: + { + OpAccessChain decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AccessChain(" + ParamToStr(idName, decoded.base) + ", " + ParamsToStr(idName, decoded.indexes) + ")"; + break; + } + case rdcspv::Op::InBoundsAccessChain: + { + OpInBoundsAccessChain decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "InBoundsAccessChain(" + ParamToStr(idName, decoded.base) + ", " + ParamsToStr(idName, decoded.indexes) + ")"; + break; + } + case rdcspv::Op::PtrAccessChain: + { + OpPtrAccessChain decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "PtrAccessChain(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.element) + ", " + ParamsToStr(idName, decoded.indexes) + ")"; + break; + } + case rdcspv::Op::ArrayLength: + { + OpArrayLength decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ArrayLength(" + ParamToStr(idName, decoded.structure) + ", " + ParamToStr(idName, decoded.arraymember) + ")"; + break; + } + case rdcspv::Op::GenericPtrMemSemantics: + { + OpGenericPtrMemSemantics decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GenericPtrMemSemantics(" + ParamToStr(idName, decoded.pointer) + ")"; + break; + } + case rdcspv::Op::InBoundsPtrAccessChain: + { + OpInBoundsPtrAccessChain decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "InBoundsPtrAccessChain(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.element) + ", " + ParamsToStr(idName, decoded.indexes) + ")"; + break; + } + case rdcspv::Op::Decorate: + { + OpDecorate decoded(it); + ret += "Decorate(" + ParamToStr(idName, decoded.target) + ", " + ParamToStr(idName, decoded.decoration) + ")"; + break; + } + case rdcspv::Op::MemberDecorate: + { + OpMemberDecorate decoded(it); + ret += "MemberDecorate(" + ParamToStr(idName, decoded.structureType) + ", " + ParamToStr(idName, decoded.member) + ", " + ParamToStr(idName, decoded.decoration) + ")"; + break; + } + case rdcspv::Op::DecorationGroup: + { + OpDecorationGroup decoded(it); + ret += idName(decoded.result) + " = "; + ret += "DecorationGroup(" ")"; + break; + } + case rdcspv::Op::GroupDecorate: + { + OpGroupDecorate decoded(it); + ret += "GroupDecorate(" + ParamToStr(idName, decoded.decorationGroup) + ", " + ParamsToStr(idName, decoded.targets) + ")"; + break; + } + case rdcspv::Op::GroupMemberDecorate: + { + OpGroupMemberDecorate decoded(it); + ret += "GroupMemberDecorate(" + ParamToStr(idName, decoded.decorationGroup) + ", " + ParamsToStr(idName, decoded.targets) + ")"; + break; + } + case rdcspv::Op::VectorExtractDynamic: + { + OpVectorExtractDynamic decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "VectorExtractDynamic(" + ParamToStr(idName, decoded.vector) + ", " + ParamToStr(idName, decoded.index) + ")"; + break; + } + case rdcspv::Op::VectorInsertDynamic: + { + OpVectorInsertDynamic decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "VectorInsertDynamic(" + ParamToStr(idName, decoded.vector) + ", " + ParamToStr(idName, decoded.component) + ", " + ParamToStr(idName, decoded.index) + ")"; + break; + } + case rdcspv::Op::VectorShuffle: + { + OpVectorShuffle decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "VectorShuffle(" + ParamToStr(idName, decoded.vector1) + ", " + ParamToStr(idName, decoded.vector2) + ", " + ParamsToStr(idName, decoded.components) + ")"; + break; + } + case rdcspv::Op::CompositeConstruct: + { + OpCompositeConstruct decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CompositeConstruct(" + ParamsToStr(idName, decoded.constituents) + ")"; + break; + } + case rdcspv::Op::CompositeExtract: + { + OpCompositeExtract decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CompositeExtract(" + ParamToStr(idName, decoded.composite) + ", " + ParamsToStr(idName, decoded.indexes) + ")"; + break; + } + case rdcspv::Op::CompositeInsert: + { + OpCompositeInsert decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CompositeInsert(" + ParamToStr(idName, decoded.object) + ", " + ParamToStr(idName, decoded.composite) + ", " + ParamsToStr(idName, decoded.indexes) + ")"; + break; + } + case rdcspv::Op::CopyObject: + { + OpCopyObject decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CopyObject(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::Transpose: + { + OpTranspose decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Transpose(" + ParamToStr(idName, decoded.matrix) + ")"; + break; + } + case rdcspv::Op::SampledImage: + { + OpSampledImage decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SampledImage(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.sampler) + ")"; + break; + } + case rdcspv::Op::ImageSampleImplicitLod: + { + OpImageSampleImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleExplicitLod: + { + OpImageSampleExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleDrefImplicitLod: + { + OpImageSampleDrefImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleDrefImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleDrefExplicitLod: + { + OpImageSampleDrefExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleDrefExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleProjImplicitLod: + { + OpImageSampleProjImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleProjImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleProjExplicitLod: + { + OpImageSampleProjExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleProjExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleProjDrefImplicitLod: + { + OpImageSampleProjDrefImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleProjDrefImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSampleProjDrefExplicitLod: + { + OpImageSampleProjDrefExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleProjDrefExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageFetch: + { + OpImageFetch decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageFetch(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageGather: + { + OpImageGather decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageGather(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.component) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageDrefGather: + { + OpImageDrefGather decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageDrefGather(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageRead: + { + OpImageRead decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageRead(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageWrite: + { + OpImageWrite decoded(it); + ret += "ImageWrite(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.texel) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::Image: + { + OpImage decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Image(" + ParamToStr(idName, decoded.sampledImage) + ")"; + break; + } + case rdcspv::Op::ImageQueryFormat: + { + OpImageQueryFormat decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQueryFormat(" + ParamToStr(idName, decoded.image) + ")"; + break; + } + case rdcspv::Op::ImageQueryOrder: + { + OpImageQueryOrder decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQueryOrder(" + ParamToStr(idName, decoded.image) + ")"; + break; + } + case rdcspv::Op::ImageQuerySizeLod: + { + OpImageQuerySizeLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQuerySizeLod(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.levelofDetail) + ")"; + break; + } + case rdcspv::Op::ImageQuerySize: + { + OpImageQuerySize decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQuerySize(" + ParamToStr(idName, decoded.image) + ")"; + break; + } + case rdcspv::Op::ImageQueryLod: + { + OpImageQueryLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQueryLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ")"; + break; + } + case rdcspv::Op::ImageQueryLevels: + { + OpImageQueryLevels decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQueryLevels(" + ParamToStr(idName, decoded.image) + ")"; + break; + } + case rdcspv::Op::ImageQuerySamples: + { + OpImageQuerySamples decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageQuerySamples(" + ParamToStr(idName, decoded.image) + ")"; + break; + } + case rdcspv::Op::ConvertFToU: + { + OpConvertFToU decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConvertFToU(" + ParamToStr(idName, decoded.floatValue) + ")"; + break; + } + case rdcspv::Op::ConvertFToS: + { + OpConvertFToS decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConvertFToS(" + ParamToStr(idName, decoded.floatValue) + ")"; + break; + } + case rdcspv::Op::ConvertSToF: + { + OpConvertSToF decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConvertSToF(" + ParamToStr(idName, decoded.signedValue) + ")"; + break; + } + case rdcspv::Op::ConvertUToF: + { + OpConvertUToF decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConvertUToF(" + ParamToStr(idName, decoded.unsignedValue) + ")"; + break; + } + case rdcspv::Op::UConvert: + { + OpUConvert decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UConvert(" + ParamToStr(idName, decoded.unsignedValue) + ")"; + break; + } + case rdcspv::Op::SConvert: + { + OpSConvert decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SConvert(" + ParamToStr(idName, decoded.signedValue) + ")"; + break; + } + case rdcspv::Op::FConvert: + { + OpFConvert decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FConvert(" + ParamToStr(idName, decoded.floatValue) + ")"; + break; + } + case rdcspv::Op::QuantizeToF16: + { + OpQuantizeToF16 decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "QuantizeToF16(" + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::ConvertPtrToU: + { + OpConvertPtrToU decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConvertPtrToU(" + ParamToStr(idName, decoded.pointer) + ")"; + break; + } + case rdcspv::Op::SatConvertSToU: + { + OpSatConvertSToU decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SatConvertSToU(" + ParamToStr(idName, decoded.signedValue) + ")"; + break; + } + case rdcspv::Op::SatConvertUToS: + { + OpSatConvertUToS decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SatConvertUToS(" + ParamToStr(idName, decoded.unsignedValue) + ")"; + break; + } + case rdcspv::Op::ConvertUToPtr: + { + OpConvertUToPtr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConvertUToPtr(" + ParamToStr(idName, decoded.integerValue) + ")"; + break; + } + case rdcspv::Op::PtrCastToGeneric: + { + OpPtrCastToGeneric decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "PtrCastToGeneric(" + ParamToStr(idName, decoded.pointer) + ")"; + break; + } + case rdcspv::Op::GenericCastToPtr: + { + OpGenericCastToPtr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GenericCastToPtr(" + ParamToStr(idName, decoded.pointer) + ")"; + break; + } + case rdcspv::Op::GenericCastToPtrExplicit: + { + OpGenericCastToPtrExplicit decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GenericCastToPtrExplicit(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.storage) + ")"; + break; + } + case rdcspv::Op::Bitcast: + { + OpBitcast decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Bitcast(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::SNegate: + { + OpSNegate decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SNegate(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::FNegate: + { + OpFNegate decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FNegate(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::IAdd: + { + OpIAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IAdd(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FAdd: + { + OpFAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FAdd(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::ISub: + { + OpISub decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ISub(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FSub: + { + OpFSub decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FSub(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::IMul: + { + OpIMul decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IMul(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FMul: + { + OpFMul decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FMul(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UDiv: + { + OpUDiv decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UDiv(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SDiv: + { + OpSDiv decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SDiv(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FDiv: + { + OpFDiv decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FDiv(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UMod: + { + OpUMod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UMod(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SRem: + { + OpSRem decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SRem(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SMod: + { + OpSMod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SMod(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FRem: + { + OpFRem decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FRem(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FMod: + { + OpFMod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FMod(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::VectorTimesScalar: + { + OpVectorTimesScalar decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "VectorTimesScalar(" + ParamToStr(idName, decoded.vector) + ", " + ParamToStr(idName, decoded.scalar) + ")"; + break; + } + case rdcspv::Op::MatrixTimesScalar: + { + OpMatrixTimesScalar decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "MatrixTimesScalar(" + ParamToStr(idName, decoded.matrix) + ", " + ParamToStr(idName, decoded.scalar) + ")"; + break; + } + case rdcspv::Op::VectorTimesMatrix: + { + OpVectorTimesMatrix decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "VectorTimesMatrix(" + ParamToStr(idName, decoded.vector) + ", " + ParamToStr(idName, decoded.matrix) + ")"; + break; + } + case rdcspv::Op::MatrixTimesVector: + { + OpMatrixTimesVector decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "MatrixTimesVector(" + ParamToStr(idName, decoded.matrix) + ", " + ParamToStr(idName, decoded.vector) + ")"; + break; + } + case rdcspv::Op::MatrixTimesMatrix: + { + OpMatrixTimesMatrix decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "MatrixTimesMatrix(" + ParamToStr(idName, decoded.leftMatrix) + ", " + ParamToStr(idName, decoded.rightMatrix) + ")"; + break; + } + case rdcspv::Op::OuterProduct: + { + OpOuterProduct decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "OuterProduct(" + ParamToStr(idName, decoded.vector1) + ", " + ParamToStr(idName, decoded.vector2) + ")"; + break; + } + case rdcspv::Op::Dot: + { + OpDot decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Dot(" + ParamToStr(idName, decoded.vector1) + ", " + ParamToStr(idName, decoded.vector2) + ")"; + break; + } + case rdcspv::Op::IAddCarry: + { + OpIAddCarry decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IAddCarry(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::ISubBorrow: + { + OpISubBorrow decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ISubBorrow(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UMulExtended: + { + OpUMulExtended decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UMulExtended(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SMulExtended: + { + OpSMulExtended decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SMulExtended(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::Any: + { + OpAny decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Any(" + ParamToStr(idName, decoded.vector) + ")"; + break; + } + case rdcspv::Op::All: + { + OpAll decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "All(" + ParamToStr(idName, decoded.vector) + ")"; + break; + } + case rdcspv::Op::IsNan: + { + OpIsNan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsNan(" + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::IsInf: + { + OpIsInf decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsInf(" + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::IsFinite: + { + OpIsFinite decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsFinite(" + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::IsNormal: + { + OpIsNormal decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsNormal(" + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::SignBitSet: + { + OpSignBitSet decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SignBitSet(" + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::LessOrGreater: + { + OpLessOrGreater decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "LessOrGreater(" + ParamToStr(idName, decoded.x) + ", " + ParamToStr(idName, decoded.y) + ")"; + break; + } + case rdcspv::Op::Ordered: + { + OpOrdered decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Ordered(" + ParamToStr(idName, decoded.x) + ", " + ParamToStr(idName, decoded.y) + ")"; + break; + } + case rdcspv::Op::Unordered: + { + OpUnordered decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Unordered(" + ParamToStr(idName, decoded.x) + ", " + ParamToStr(idName, decoded.y) + ")"; + break; + } + case rdcspv::Op::LogicalEqual: + { + OpLogicalEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "LogicalEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::LogicalNotEqual: + { + OpLogicalNotEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "LogicalNotEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::LogicalOr: + { + OpLogicalOr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "LogicalOr(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::LogicalAnd: + { + OpLogicalAnd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "LogicalAnd(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::LogicalNot: + { + OpLogicalNot decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "LogicalNot(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::Select: + { + OpSelect decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Select(" + ParamToStr(idName, decoded.condition) + ", " + ParamToStr(idName, decoded.object1) + ", " + ParamToStr(idName, decoded.object2) + ")"; + break; + } + case rdcspv::Op::IEqual: + { + OpIEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::INotEqual: + { + OpINotEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "INotEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UGreaterThan: + { + OpUGreaterThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UGreaterThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SGreaterThan: + { + OpSGreaterThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SGreaterThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UGreaterThanEqual: + { + OpUGreaterThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UGreaterThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SGreaterThanEqual: + { + OpSGreaterThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SGreaterThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::ULessThan: + { + OpULessThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ULessThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SLessThan: + { + OpSLessThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SLessThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::ULessThanEqual: + { + OpULessThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ULessThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SLessThanEqual: + { + OpSLessThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SLessThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FOrdEqual: + { + OpFOrdEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FOrdEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FUnordEqual: + { + OpFUnordEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FUnordEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FOrdNotEqual: + { + OpFOrdNotEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FOrdNotEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FUnordNotEqual: + { + OpFUnordNotEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FUnordNotEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FOrdLessThan: + { + OpFOrdLessThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FOrdLessThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FUnordLessThan: + { + OpFUnordLessThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FUnordLessThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FOrdGreaterThan: + { + OpFOrdGreaterThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FOrdGreaterThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FUnordGreaterThan: + { + OpFUnordGreaterThan decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FUnordGreaterThan(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FOrdLessThanEqual: + { + OpFOrdLessThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FOrdLessThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FUnordLessThanEqual: + { + OpFUnordLessThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FUnordLessThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FOrdGreaterThanEqual: + { + OpFOrdGreaterThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FOrdGreaterThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::FUnordGreaterThanEqual: + { + OpFUnordGreaterThanEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FUnordGreaterThanEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::ShiftRightLogical: + { + OpShiftRightLogical decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ShiftRightLogical(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.shift) + ")"; + break; + } + case rdcspv::Op::ShiftRightArithmetic: + { + OpShiftRightArithmetic decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ShiftRightArithmetic(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.shift) + ")"; + break; + } + case rdcspv::Op::ShiftLeftLogical: + { + OpShiftLeftLogical decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ShiftLeftLogical(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.shift) + ")"; + break; + } + case rdcspv::Op::BitwiseOr: + { + OpBitwiseOr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitwiseOr(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::BitwiseXor: + { + OpBitwiseXor decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitwiseXor(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::BitwiseAnd: + { + OpBitwiseAnd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitwiseAnd(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::Not: + { + OpNot decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Not(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::BitFieldInsert: + { + OpBitFieldInsert decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitFieldInsert(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.insert) + ", " + ParamToStr(idName, decoded.offset) + ", " + ParamToStr(idName, decoded.count) + ")"; + break; + } + case rdcspv::Op::BitFieldSExtract: + { + OpBitFieldSExtract decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitFieldSExtract(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.offset) + ", " + ParamToStr(idName, decoded.count) + ")"; + break; + } + case rdcspv::Op::BitFieldUExtract: + { + OpBitFieldUExtract decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitFieldUExtract(" + ParamToStr(idName, decoded.base) + ", " + ParamToStr(idName, decoded.offset) + ", " + ParamToStr(idName, decoded.count) + ")"; + break; + } + case rdcspv::Op::BitReverse: + { + OpBitReverse decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitReverse(" + ParamToStr(idName, decoded.base) + ")"; + break; + } + case rdcspv::Op::BitCount: + { + OpBitCount decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BitCount(" + ParamToStr(idName, decoded.base) + ")"; + break; + } + case rdcspv::Op::DPdx: + { + OpDPdx decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "DPdx(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::DPdy: + { + OpDPdy decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "DPdy(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::Fwidth: + { + OpFwidth decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Fwidth(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::DPdxFine: + { + OpDPdxFine decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "DPdxFine(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::DPdyFine: + { + OpDPdyFine decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "DPdyFine(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::FwidthFine: + { + OpFwidthFine decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FwidthFine(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::DPdxCoarse: + { + OpDPdxCoarse decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "DPdxCoarse(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::DPdyCoarse: + { + OpDPdyCoarse decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "DPdyCoarse(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::FwidthCoarse: + { + OpFwidthCoarse decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FwidthCoarse(" + ParamToStr(idName, decoded.p) + ")"; + break; + } + case rdcspv::Op::EmitVertex: + { + OpEmitVertex decoded(it); + ret += "EmitVertex(" ")"; + break; + } + case rdcspv::Op::EndPrimitive: + { + OpEndPrimitive decoded(it); + ret += "EndPrimitive(" ")"; + break; + } + case rdcspv::Op::EmitStreamVertex: + { + OpEmitStreamVertex decoded(it); + ret += "EmitStreamVertex(" + ParamToStr(idName, decoded.stream) + ")"; + break; + } + case rdcspv::Op::EndStreamPrimitive: + { + OpEndStreamPrimitive decoded(it); + ret += "EndStreamPrimitive(" + ParamToStr(idName, decoded.stream) + ")"; + break; + } + case rdcspv::Op::ControlBarrier: + { + OpControlBarrier decoded(it); + ret += "ControlBarrier(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::MemoryBarrier: + { + OpMemoryBarrier decoded(it); + ret += "MemoryBarrier(" + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::AtomicLoad: + { + OpAtomicLoad decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicLoad(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::AtomicStore: + { + OpAtomicStore decoded(it); + ret += "AtomicStore(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicExchange: + { + OpAtomicExchange decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicExchange(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicCompareExchange: + { + OpAtomicCompareExchange decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicCompareExchange(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.equal))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.unequal))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.comparator) + ")"; + break; + } + case rdcspv::Op::AtomicCompareExchangeWeak: + { + OpAtomicCompareExchangeWeak decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicCompareExchangeWeak(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.equal))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.unequal))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.comparator) + ")"; + break; + } + case rdcspv::Op::AtomicIIncrement: + { + OpAtomicIIncrement decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicIIncrement(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::AtomicIDecrement: + { + OpAtomicIDecrement decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicIDecrement(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::AtomicIAdd: + { + OpAtomicIAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicIAdd(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicISub: + { + OpAtomicISub decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicISub(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicSMin: + { + OpAtomicSMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicSMin(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicUMin: + { + OpAtomicUMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicUMin(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicSMax: + { + OpAtomicSMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicSMax(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicUMax: + { + OpAtomicUMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicUMax(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicAnd: + { + OpAtomicAnd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicAnd(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicOr: + { + OpAtomicOr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicOr(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::AtomicXor: + { + OpAtomicXor decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicXor(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::Phi: + { + OpPhi decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "Phi(" + ParamsToStr(idName, decoded.parents) + ")"; + break; + } + case rdcspv::Op::LoopMerge: + { + OpLoopMerge decoded(it); + ret += "LoopMerge(" + ParamToStr(idName, decoded.mergeBlock) + ", " + ParamToStr(idName, decoded.continueTarget) + ", " + ParamToStr(idName, decoded.loopControl) + ")"; + break; + } + case rdcspv::Op::SelectionMerge: + { + OpSelectionMerge decoded(it); + ret += "SelectionMerge(" + ParamToStr(idName, decoded.mergeBlock) + ", " + ParamToStr(idName, decoded.selectionControl) + ")"; + break; + } + case rdcspv::Op::Label: + { + OpLabel decoded(it); + ret += idName(decoded.result) + " = "; + ret += "Label(" ")"; + break; + } + case rdcspv::Op::Branch: + { + OpBranch decoded(it); + ret += "Branch(" + ParamToStr(idName, decoded.targetLabel) + ")"; + break; + } + case rdcspv::Op::BranchConditional: + { + OpBranchConditional decoded(it); + ret += "BranchConditional(" + ParamToStr(idName, decoded.condition) + ", " + ParamToStr(idName, decoded.trueLabel) + ", " + ParamToStr(idName, decoded.falseLabel) + ", " + ParamsToStr(idName, decoded.branchweights) + ")"; + break; + } + case rdcspv::Op::Switch: + { + OpSwitch decoded(it); + ret += "Switch(" + ParamToStr(idName, decoded.selector) + ", " + ParamToStr(idName, decoded.def) + ", " + ParamsToStr(idName, decoded.target) + ")"; + break; + } + case rdcspv::Op::Kill: + { + OpKill decoded(it); + ret += "Kill(" ")"; + break; + } + case rdcspv::Op::Return: + { + OpReturn decoded(it); + ret += "Return(" ")"; + break; + } + case rdcspv::Op::ReturnValue: + { + OpReturnValue decoded(it); + ret += "ReturnValue(" + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::Unreachable: + { + OpUnreachable decoded(it); + ret += "Unreachable(" ")"; + break; + } + case rdcspv::Op::LifetimeStart: + { + OpLifetimeStart decoded(it); + ret += "LifetimeStart(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.size) + ")"; + break; + } + case rdcspv::Op::LifetimeStop: + { + OpLifetimeStop decoded(it); + ret += "LifetimeStop(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.size) + ")"; + break; + } + case rdcspv::Op::GroupAsyncCopy: + { + OpGroupAsyncCopy decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupAsyncCopy(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.destination) + ", " + ParamToStr(idName, decoded.source) + ", " + ParamToStr(idName, decoded.numElements) + ", " + ParamToStr(idName, decoded.stride) + ", " + ParamToStr(idName, decoded.event) + ")"; + break; + } + case rdcspv::Op::GroupWaitEvents: + { + OpGroupWaitEvents decoded(it); + ret += "GroupWaitEvents(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.numEvents) + ", " + ParamToStr(idName, decoded.eventsList) + ")"; + break; + } + case rdcspv::Op::GroupAll: + { + OpGroupAll decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupAll(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::GroupAny: + { + OpGroupAny decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupAny(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::GroupBroadcast: + { + OpGroupBroadcast decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupBroadcast(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.localId) + ")"; + break; + } + case rdcspv::Op::GroupIAdd: + { + OpGroupIAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupIAdd(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupFAdd: + { + OpGroupFAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupFAdd(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupFMin: + { + OpGroupFMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupFMin(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupUMin: + { + OpGroupUMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupUMin(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupSMin: + { + OpGroupSMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupSMin(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupFMax: + { + OpGroupFMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupFMax(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupUMax: + { + OpGroupUMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupUMax(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupSMax: + { + OpGroupSMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupSMax(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::ReadPipe: + { + OpReadPipe decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReadPipe(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::WritePipe: + { + OpWritePipe decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "WritePipe(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::ReservedReadPipe: + { + OpReservedReadPipe decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReservedReadPipe(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.reserveId) + ", " + ParamToStr(idName, decoded.index) + ", " + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::ReservedWritePipe: + { + OpReservedWritePipe decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReservedWritePipe(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.reserveId) + ", " + ParamToStr(idName, decoded.index) + ", " + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::ReserveReadPipePackets: + { + OpReserveReadPipePackets decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReserveReadPipePackets(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.numPackets) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::ReserveWritePipePackets: + { + OpReserveWritePipePackets decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReserveWritePipePackets(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.numPackets) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::CommitReadPipe: + { + OpCommitReadPipe decoded(it); + ret += "CommitReadPipe(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.reserveId) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::CommitWritePipe: + { + OpCommitWritePipe decoded(it); + ret += "CommitWritePipe(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.reserveId) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::IsValidReserveId: + { + OpIsValidReserveId decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsValidReserveId(" + ParamToStr(idName, decoded.reserveId) + ")"; + break; + } + case rdcspv::Op::GetNumPipePackets: + { + OpGetNumPipePackets decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetNumPipePackets(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::GetMaxPipePackets: + { + OpGetMaxPipePackets decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetMaxPipePackets(" + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::GroupReserveReadPipePackets: + { + OpGroupReserveReadPipePackets decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupReserveReadPipePackets(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.numPackets) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::GroupReserveWritePipePackets: + { + OpGroupReserveWritePipePackets decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupReserveWritePipePackets(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.numPackets) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::GroupCommitReadPipe: + { + OpGroupCommitReadPipe decoded(it); + ret += "GroupCommitReadPipe(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.reserveId) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::GroupCommitWritePipe: + { + OpGroupCommitWritePipe decoded(it); + ret += "GroupCommitWritePipe(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.pipe) + ", " + ParamToStr(idName, decoded.reserveId) + ", " + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ")"; + break; + } + case rdcspv::Op::EnqueueMarker: + { + OpEnqueueMarker decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "EnqueueMarker(" + ParamToStr(idName, decoded.queue) + ", " + ParamToStr(idName, decoded.numEvents) + ", " + ParamToStr(idName, decoded.waitEvents) + ", " + ParamToStr(idName, decoded.retEvent) + ")"; + break; + } + case rdcspv::Op::EnqueueKernel: + { + OpEnqueueKernel decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "EnqueueKernel(" + ParamToStr(idName, decoded.queue) + ", " + ParamToStr(idName, decoded.flags) + ", " + ParamToStr(idName, decoded.nDRange) + ", " + ParamToStr(idName, decoded.numEvents) + ", " + ParamToStr(idName, decoded.waitEvents) + ", " + ParamToStr(idName, decoded.retEvent) + ", " + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ", " + ParamsToStr(idName, decoded.localSize) + ")"; + break; + } + case rdcspv::Op::GetKernelNDrangeSubGroupCount: + { + OpGetKernelNDrangeSubGroupCount decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetKernelNDrangeSubGroupCount(" + ParamToStr(idName, decoded.nDRange) + ", " + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ")"; + break; + } + case rdcspv::Op::GetKernelNDrangeMaxSubGroupSize: + { + OpGetKernelNDrangeMaxSubGroupSize decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetKernelNDrangeMaxSubGroupSize(" + ParamToStr(idName, decoded.nDRange) + ", " + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ")"; + break; + } + case rdcspv::Op::GetKernelWorkGroupSize: + { + OpGetKernelWorkGroupSize decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetKernelWorkGroupSize(" + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ")"; + break; + } + case rdcspv::Op::GetKernelPreferredWorkGroupSizeMultiple: + { + OpGetKernelPreferredWorkGroupSizeMultiple decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetKernelPreferredWorkGroupSizeMultiple(" + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ")"; + break; + } + case rdcspv::Op::RetainEvent: + { + OpRetainEvent decoded(it); + ret += "RetainEvent(" + ParamToStr(idName, decoded.event) + ")"; + break; + } + case rdcspv::Op::ReleaseEvent: + { + OpReleaseEvent decoded(it); + ret += "ReleaseEvent(" + ParamToStr(idName, decoded.event) + ")"; + break; + } + case rdcspv::Op::CreateUserEvent: + { + OpCreateUserEvent decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CreateUserEvent(" ")"; + break; + } + case rdcspv::Op::IsValidEvent: + { + OpIsValidEvent decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsValidEvent(" + ParamToStr(idName, decoded.event) + ")"; + break; + } + case rdcspv::Op::SetUserEventStatus: + { + OpSetUserEventStatus decoded(it); + ret += "SetUserEventStatus(" + ParamToStr(idName, decoded.event) + ", " + ParamToStr(idName, decoded.status) + ")"; + break; + } + case rdcspv::Op::CaptureEventProfilingInfo: + { + OpCaptureEventProfilingInfo decoded(it); + ret += "CaptureEventProfilingInfo(" + ParamToStr(idName, decoded.event) + ", " + ParamToStr(idName, decoded.profilingInfo) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GetDefaultQueue: + { + OpGetDefaultQueue decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetDefaultQueue(" ")"; + break; + } + case rdcspv::Op::BuildNDRange: + { + OpBuildNDRange decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "BuildNDRange(" + ParamToStr(idName, decoded.globalWorkSize) + ", " + ParamToStr(idName, decoded.localWorkSize) + ", " + ParamToStr(idName, decoded.globalWorkOffset) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleImplicitLod: + { + OpImageSparseSampleImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleExplicitLod: + { + OpImageSparseSampleExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleDrefImplicitLod: + { + OpImageSparseSampleDrefImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleDrefImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleDrefExplicitLod: + { + OpImageSparseSampleDrefExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleDrefExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleProjImplicitLod: + { + OpImageSparseSampleProjImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleProjImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleProjExplicitLod: + { + OpImageSparseSampleProjExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleProjExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleProjDrefImplicitLod: + { + OpImageSparseSampleProjDrefImplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleProjDrefImplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseSampleProjDrefExplicitLod: + { + OpImageSparseSampleProjDrefExplicitLod decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseSampleProjDrefExplicitLod(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseFetch: + { + OpImageSparseFetch decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseFetch(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseGather: + { + OpImageSparseGather decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseGather(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.component) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseDrefGather: + { + OpImageSparseDrefGather decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseDrefGather(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.dref) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::ImageSparseTexelsResident: + { + OpImageSparseTexelsResident decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseTexelsResident(" + ParamToStr(idName, decoded.residentCode) + ")"; + break; + } + case rdcspv::Op::NoLine: + { + OpNoLine decoded(it); + ret += "NoLine(" ")"; + break; + } + case rdcspv::Op::AtomicFlagTestAndSet: + { + OpAtomicFlagTestAndSet decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AtomicFlagTestAndSet(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::AtomicFlagClear: + { + OpAtomicFlagClear decoded(it); + ret += "AtomicFlagClear(" + ParamToStr(idName, decoded.pointer) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::ImageSparseRead: + { + OpImageSparseRead decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSparseRead(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::SizeOf: + { + OpSizeOf decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SizeOf(" + ParamToStr(idName, decoded.pointer) + ")"; + break; + } + case rdcspv::Op::TypePipeStorage: + { + OpTypePipeStorage decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypePipeStorage(" ")"; + break; + } + case rdcspv::Op::ConstantPipeStorage: + { + OpConstantPipeStorage decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ConstantPipeStorage(" + ParamToStr(idName, decoded.packetSize) + ", " + ParamToStr(idName, decoded.packetAlignment) + ", " + ParamToStr(idName, decoded.capacity) + ")"; + break; + } + case rdcspv::Op::CreatePipeFromPipeStorage: + { + OpCreatePipeFromPipeStorage decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CreatePipeFromPipeStorage(" + ParamToStr(idName, decoded.pipeStorage) + ")"; + break; + } + case rdcspv::Op::GetKernelLocalSizeForSubgroupCount: + { + OpGetKernelLocalSizeForSubgroupCount decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetKernelLocalSizeForSubgroupCount(" + ParamToStr(idName, decoded.subgroupCount) + ", " + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ")"; + break; + } + case rdcspv::Op::GetKernelMaxNumSubgroups: + { + OpGetKernelMaxNumSubgroups decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GetKernelMaxNumSubgroups(" + ParamToStr(idName, decoded.invoke) + ", " + ParamToStr(idName, decoded.param) + ", " + ParamToStr(idName, decoded.paramSize) + ", " + ParamToStr(idName, decoded.paramAlign) + ")"; + break; + } + case rdcspv::Op::TypeNamedBarrier: + { + OpTypeNamedBarrier decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeNamedBarrier(" ")"; + break; + } + case rdcspv::Op::NamedBarrierInitialize: + { + OpNamedBarrierInitialize decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "NamedBarrierInitialize(" + ParamToStr(idName, decoded.subgroupCount) + ")"; + break; + } + case rdcspv::Op::MemoryNamedBarrier: + { + OpMemoryNamedBarrier decoded(it); + ret += "MemoryNamedBarrier(" + ParamToStr(idName, decoded.namedBarrier) + ", " + ToStr(Scope(constIntVal(decoded.memory))) + ", " + ToStr(MemorySemantics(constIntVal(decoded.semantics))) + ")"; + break; + } + case rdcspv::Op::ModuleProcessed: + { + OpModuleProcessed decoded(it); + ret += "ModuleProcessed(" + ParamToStr(idName, decoded.process) + ")"; + break; + } + case rdcspv::Op::ExecutionModeId: + { + OpExecutionModeId decoded(it); + ret += "ExecutionModeId(" + ParamToStr(idName, decoded.entryPoint) + ", " + ParamToStr(idName, decoded.mode) + ")"; + break; + } + case rdcspv::Op::DecorateId: + { + OpDecorateId decoded(it); + ret += "DecorateId(" + ParamToStr(idName, decoded.target) + ", " + ParamToStr(idName, decoded.decoration) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformElect: + { + OpGroupNonUniformElect decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformElect(" + ToStr(Scope(constIntVal(decoded.execution))) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformAll: + { + OpGroupNonUniformAll decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformAll(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformAny: + { + OpGroupNonUniformAny decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformAny(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformAllEqual: + { + OpGroupNonUniformAllEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformAllEqual(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBroadcast: + { + OpGroupNonUniformBroadcast decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBroadcast(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.id) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBroadcastFirst: + { + OpGroupNonUniformBroadcastFirst decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBroadcastFirst(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBallot: + { + OpGroupNonUniformBallot decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBallot(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformInverseBallot: + { + OpGroupNonUniformInverseBallot decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformInverseBallot(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBallotBitExtract: + { + OpGroupNonUniformBallotBitExtract decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBallotBitExtract(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.index) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBallotBitCount: + { + OpGroupNonUniformBallotBitCount decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBallotBitCount(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBallotFindLSB: + { + OpGroupNonUniformBallotFindLSB decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBallotFindLSB(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBallotFindMSB: + { + OpGroupNonUniformBallotFindMSB decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBallotFindMSB(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformShuffle: + { + OpGroupNonUniformShuffle decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformShuffle(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.id) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformShuffleXor: + { + OpGroupNonUniformShuffleXor decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformShuffleXor(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.mask) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformShuffleUp: + { + OpGroupNonUniformShuffleUp decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformShuffleUp(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.delta) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformShuffleDown: + { + OpGroupNonUniformShuffleDown decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformShuffleDown(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.delta) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformIAdd: + { + OpGroupNonUniformIAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformIAdd(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformFAdd: + { + OpGroupNonUniformFAdd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformFAdd(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformIMul: + { + OpGroupNonUniformIMul decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformIMul(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformFMul: + { + OpGroupNonUniformFMul decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformFMul(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformSMin: + { + OpGroupNonUniformSMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformSMin(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformUMin: + { + OpGroupNonUniformUMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformUMin(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformFMin: + { + OpGroupNonUniformFMin decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformFMin(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformSMax: + { + OpGroupNonUniformSMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformSMax(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformUMax: + { + OpGroupNonUniformUMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformUMax(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformFMax: + { + OpGroupNonUniformFMax decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformFMax(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBitwiseAnd: + { + OpGroupNonUniformBitwiseAnd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBitwiseAnd(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBitwiseOr: + { + OpGroupNonUniformBitwiseOr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBitwiseOr(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformBitwiseXor: + { + OpGroupNonUniformBitwiseXor decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformBitwiseXor(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformLogicalAnd: + { + OpGroupNonUniformLogicalAnd decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformLogicalAnd(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformLogicalOr: + { + OpGroupNonUniformLogicalOr decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformLogicalOr(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformLogicalXor: + { + OpGroupNonUniformLogicalXor decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformLogicalXor(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.clusterSize) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformQuadBroadcast: + { + OpGroupNonUniformQuadBroadcast decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformQuadBroadcast(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.index) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformQuadSwap: + { + OpGroupNonUniformQuadSwap decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformQuadSwap(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.direction) + ")"; + break; + } + case rdcspv::Op::CopyLogical: + { + OpCopyLogical decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CopyLogical(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::PtrEqual: + { + OpPtrEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "PtrEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::PtrNotEqual: + { + OpPtrNotEqual decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "PtrNotEqual(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::PtrDiff: + { + OpPtrDiff decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "PtrDiff(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::SubgroupBallotKHR: + { + OpSubgroupBallotKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupBallotKHR(" + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::SubgroupFirstInvocationKHR: + { + OpSubgroupFirstInvocationKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupFirstInvocationKHR(" + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::SubgroupAllKHR: + { + OpSubgroupAllKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAllKHR(" + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::SubgroupAnyKHR: + { + OpSubgroupAnyKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAnyKHR(" + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::SubgroupAllEqualKHR: + { + OpSubgroupAllEqualKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAllEqualKHR(" + ParamToStr(idName, decoded.predicate) + ")"; + break; + } + case rdcspv::Op::SubgroupReadInvocationKHR: + { + OpSubgroupReadInvocationKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupReadInvocationKHR(" + ParamToStr(idName, decoded.value) + ", " + ParamToStr(idName, decoded.index) + ")"; + break; + } + case rdcspv::Op::GroupIAddNonUniformAMD: + { + OpGroupIAddNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupIAddNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupFAddNonUniformAMD: + { + OpGroupFAddNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupFAddNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupFMinNonUniformAMD: + { + OpGroupFMinNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupFMinNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupUMinNonUniformAMD: + { + OpGroupUMinNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupUMinNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupSMinNonUniformAMD: + { + OpGroupSMinNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupSMinNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupFMaxNonUniformAMD: + { + OpGroupFMaxNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupFMaxNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupUMaxNonUniformAMD: + { + OpGroupUMaxNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupUMaxNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::GroupSMaxNonUniformAMD: + { + OpGroupSMaxNonUniformAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupSMaxNonUniformAMD(" + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.operation) + ", " + ParamToStr(idName, decoded.x) + ")"; + break; + } + case rdcspv::Op::FragmentMaskFetchAMD: + { + OpFragmentMaskFetchAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FragmentMaskFetchAMD(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ")"; + break; + } + case rdcspv::Op::FragmentFetchAMD: + { + OpFragmentFetchAMD decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "FragmentFetchAMD(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.fragmentIndex) + ")"; + break; + } + case rdcspv::Op::ReadClockKHR: + { + OpReadClockKHR decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReadClockKHR(" + ToStr(Scope(constIntVal(decoded.execution))) + ")"; + break; + } + case rdcspv::Op::ImageSampleFootprintNV: + { + OpImageSampleFootprintNV decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ImageSampleFootprintNV(" + ParamToStr(idName, decoded.sampledImage) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.granularity) + ", " + ParamToStr(idName, decoded.coarse) + ", " + ParamToStr(idName, decoded.imageOperands) + ")"; + break; + } + case rdcspv::Op::GroupNonUniformPartitionNV: + { + OpGroupNonUniformPartitionNV decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "GroupNonUniformPartitionNV(" + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::WritePackedPrimitiveIndices4x8NV: + { + OpWritePackedPrimitiveIndices4x8NV decoded(it); + ret += "WritePackedPrimitiveIndices4x8NV(" + ParamToStr(idName, decoded.indexOffset) + ", " + ParamToStr(idName, decoded.packedIndices) + ")"; + break; + } + case rdcspv::Op::ReportIntersectionNV: + { + OpReportIntersectionNV decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ReportIntersectionNV(" + ParamToStr(idName, decoded.hit) + ", " + ParamToStr(idName, decoded.hitKind) + ")"; + break; + } + case rdcspv::Op::IgnoreIntersectionNV: + { + OpIgnoreIntersectionNV decoded(it); + ret += "IgnoreIntersectionNV(" ")"; + break; + } + case rdcspv::Op::TerminateRayNV: + { + OpTerminateRayNV decoded(it); + ret += "TerminateRayNV(" ")"; + break; + } + case rdcspv::Op::TraceNV: + { + OpTraceNV decoded(it); + ret += "TraceNV(" + ParamToStr(idName, decoded.accel) + ", " + ParamToStr(idName, decoded.rayFlags) + ", " + ParamToStr(idName, decoded.cullMask) + ", " + ParamToStr(idName, decoded.sBTOffset) + ", " + ParamToStr(idName, decoded.sBTStride) + ", " + ParamToStr(idName, decoded.missIndex) + ", " + ParamToStr(idName, decoded.rayOrigin) + ", " + ParamToStr(idName, decoded.rayTmin) + ", " + ParamToStr(idName, decoded.rayDirection) + ", " + ParamToStr(idName, decoded.rayTmax) + ", " + ParamToStr(idName, decoded.payloadId) + ")"; + break; + } + case rdcspv::Op::TypeAccelerationStructureNV: + { + OpTypeAccelerationStructureNV decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAccelerationStructureNV(" ")"; + break; + } + case rdcspv::Op::ExecuteCallableNV: + { + OpExecuteCallableNV decoded(it); + ret += "ExecuteCallableNV(" + ParamToStr(idName, decoded.sBTIndex) + ", " + ParamToStr(idName, decoded.callableDataId) + ")"; + break; + } + case rdcspv::Op::TypeCooperativeMatrixNV: + { + OpTypeCooperativeMatrixNV decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeCooperativeMatrixNV(" + ParamToStr(idName, decoded.componentType) + ", " + ToStr(Scope(constIntVal(decoded.execution))) + ", " + ParamToStr(idName, decoded.rows) + ", " + ParamToStr(idName, decoded.columns) + ")"; + break; + } + case rdcspv::Op::CooperativeMatrixLoadNV: + { + OpCooperativeMatrixLoadNV decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CooperativeMatrixLoadNV(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.stride) + ", " + ParamToStr(idName, decoded.columnMajor) + ", " + ParamToStr(idName, decoded.memoryAccess) + ")"; + break; + } + case rdcspv::Op::CooperativeMatrixStoreNV: + { + OpCooperativeMatrixStoreNV decoded(it); + ret += "CooperativeMatrixStoreNV(" + ParamToStr(idName, decoded.pointer) + ", " + ParamToStr(idName, decoded.object) + ", " + ParamToStr(idName, decoded.stride) + ", " + ParamToStr(idName, decoded.columnMajor) + ", " + ParamToStr(idName, decoded.memoryAccess) + ")"; + break; + } + case rdcspv::Op::CooperativeMatrixMulAddNV: + { + OpCooperativeMatrixMulAddNV decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CooperativeMatrixMulAddNV(" + ParamToStr(idName, decoded.a) + ", " + ParamToStr(idName, decoded.b) + ", " + ParamToStr(idName, decoded.c) + ")"; + break; + } + case rdcspv::Op::CooperativeMatrixLengthNV: + { + OpCooperativeMatrixLengthNV decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "CooperativeMatrixLengthNV(" + ParamToStr(idName, decoded.type) + ")"; + break; + } + case rdcspv::Op::BeginInvocationInterlockEXT: + { + OpBeginInvocationInterlockEXT decoded(it); + ret += "BeginInvocationInterlockEXT(" ")"; + break; + } + case rdcspv::Op::EndInvocationInterlockEXT: + { + OpEndInvocationInterlockEXT decoded(it); + ret += "EndInvocationInterlockEXT(" ")"; + break; + } + case rdcspv::Op::DemoteToHelperInvocationEXT: + { + OpDemoteToHelperInvocationEXT decoded(it); + ret += "DemoteToHelperInvocationEXT(" ")"; + break; + } + case rdcspv::Op::IsHelperInvocationEXT: + { + OpIsHelperInvocationEXT decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IsHelperInvocationEXT(" ")"; + break; + } + case rdcspv::Op::SubgroupShuffleINTEL: + { + OpSubgroupShuffleINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupShuffleINTEL(" + ParamToStr(idName, decoded.data) + ", " + ParamToStr(idName, decoded.invocationId) + ")"; + break; + } + case rdcspv::Op::SubgroupShuffleDownINTEL: + { + OpSubgroupShuffleDownINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupShuffleDownINTEL(" + ParamToStr(idName, decoded.current) + ", " + ParamToStr(idName, decoded.next) + ", " + ParamToStr(idName, decoded.delta) + ")"; + break; + } + case rdcspv::Op::SubgroupShuffleUpINTEL: + { + OpSubgroupShuffleUpINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupShuffleUpINTEL(" + ParamToStr(idName, decoded.previous) + ", " + ParamToStr(idName, decoded.current) + ", " + ParamToStr(idName, decoded.delta) + ")"; + break; + } + case rdcspv::Op::SubgroupShuffleXorINTEL: + { + OpSubgroupShuffleXorINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupShuffleXorINTEL(" + ParamToStr(idName, decoded.data) + ", " + ParamToStr(idName, decoded.value) + ")"; + break; + } + case rdcspv::Op::SubgroupBlockReadINTEL: + { + OpSubgroupBlockReadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupBlockReadINTEL(" + ParamToStr(idName, decoded.ptr) + ")"; + break; + } + case rdcspv::Op::SubgroupBlockWriteINTEL: + { + OpSubgroupBlockWriteINTEL decoded(it); + ret += "SubgroupBlockWriteINTEL(" + ParamToStr(idName, decoded.ptr) + ", " + ParamToStr(idName, decoded.data) + ")"; + break; + } + case rdcspv::Op::SubgroupImageBlockReadINTEL: + { + OpSubgroupImageBlockReadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupImageBlockReadINTEL(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ")"; + break; + } + case rdcspv::Op::SubgroupImageBlockWriteINTEL: + { + OpSubgroupImageBlockWriteINTEL decoded(it); + ret += "SubgroupImageBlockWriteINTEL(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.data) + ")"; + break; + } + case rdcspv::Op::SubgroupImageMediaBlockReadINTEL: + { + OpSubgroupImageMediaBlockReadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupImageMediaBlockReadINTEL(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.width) + ", " + ParamToStr(idName, decoded.height) + ")"; + break; + } + case rdcspv::Op::SubgroupImageMediaBlockWriteINTEL: + { + OpSubgroupImageMediaBlockWriteINTEL decoded(it); + ret += "SubgroupImageMediaBlockWriteINTEL(" + ParamToStr(idName, decoded.image) + ", " + ParamToStr(idName, decoded.coordinate) + ", " + ParamToStr(idName, decoded.width) + ", " + ParamToStr(idName, decoded.height) + ", " + ParamToStr(idName, decoded.data) + ")"; + break; + } + case rdcspv::Op::UCountLeadingZerosINTEL: + { + OpUCountLeadingZerosINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UCountLeadingZerosINTEL(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::UCountTrailingZerosINTEL: + { + OpUCountTrailingZerosINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UCountTrailingZerosINTEL(" + ParamToStr(idName, decoded.operand) + ")"; + break; + } + case rdcspv::Op::AbsISubINTEL: + { + OpAbsISubINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AbsISubINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::AbsUSubINTEL: + { + OpAbsUSubINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "AbsUSubINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::IAddSatINTEL: + { + OpIAddSatINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IAddSatINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UAddSatINTEL: + { + OpUAddSatINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UAddSatINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::IAverageINTEL: + { + OpIAverageINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IAverageINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UAverageINTEL: + { + OpUAverageINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UAverageINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::IAverageRoundedINTEL: + { + OpIAverageRoundedINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IAverageRoundedINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UAverageRoundedINTEL: + { + OpUAverageRoundedINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UAverageRoundedINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::ISubSatINTEL: + { + OpISubSatINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "ISubSatINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::USubSatINTEL: + { + OpUSubSatINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "USubSatINTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::IMul32x16INTEL: + { + OpIMul32x16INTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "IMul32x16INTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::UMul32x16INTEL: + { + OpUMul32x16INTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "UMul32x16INTEL(" + ParamToStr(idName, decoded.operand1) + ", " + ParamToStr(idName, decoded.operand2) + ")"; + break; + } + case rdcspv::Op::DecorateString: + { + OpDecorateString decoded(it); + ret += "DecorateString(" + ParamToStr(idName, decoded.target) + ", " + ParamToStr(idName, decoded.decoration) + ")"; + break; + } + case rdcspv::Op::MemberDecorateString: + { + OpMemberDecorateString decoded(it); + ret += "MemberDecorateString(" + ParamToStr(idName, decoded.structType) + ", " + ParamToStr(idName, decoded.member) + ", " + ParamToStr(idName, decoded.decoration) + ")"; + break; + } + case rdcspv::Op::VmeImageINTEL: + { + OpVmeImageINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "VmeImageINTEL(" + ParamToStr(idName, decoded.imageType) + ", " + ParamToStr(idName, decoded.sampler) + ")"; + break; + } + case rdcspv::Op::TypeVmeImageINTEL: + { + OpTypeVmeImageINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeVmeImageINTEL(" + ParamToStr(idName, decoded.imageType) + ")"; + break; + } + case rdcspv::Op::TypeAvcImePayloadINTEL: + { + OpTypeAvcImePayloadINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcImePayloadINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcRefPayloadINTEL: + { + OpTypeAvcRefPayloadINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcRefPayloadINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcSicPayloadINTEL: + { + OpTypeAvcSicPayloadINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcSicPayloadINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcMcePayloadINTEL: + { + OpTypeAvcMcePayloadINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcMcePayloadINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcMceResultINTEL: + { + OpTypeAvcMceResultINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcMceResultINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcImeResultINTEL: + { + OpTypeAvcImeResultINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcImeResultINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcImeResultSingleReferenceStreamoutINTEL: + { + OpTypeAvcImeResultSingleReferenceStreamoutINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcImeResultSingleReferenceStreamoutINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcImeResultDualReferenceStreamoutINTEL: + { + OpTypeAvcImeResultDualReferenceStreamoutINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcImeResultDualReferenceStreamoutINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcImeSingleReferenceStreaminINTEL: + { + OpTypeAvcImeSingleReferenceStreaminINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcImeSingleReferenceStreaminINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcImeDualReferenceStreaminINTEL: + { + OpTypeAvcImeDualReferenceStreaminINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcImeDualReferenceStreaminINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcRefResultINTEL: + { + OpTypeAvcRefResultINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcRefResultINTEL(" ")"; + break; + } + case rdcspv::Op::TypeAvcSicResultINTEL: + { + OpTypeAvcSicResultINTEL decoded(it); + ret += idName(decoded.result) + " = "; + ret += "TypeAvcSicResultINTEL(" ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL(" + ParamToStr(idName, decoded.sliceType) + ", " + ParamToStr(idName, decoded.qp) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: + { + OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL(" + ParamToStr(idName, decoded.referenceBasePenalty) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultInterShapePenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultInterShapePenaltyINTEL(" + ParamToStr(idName, decoded.sliceType) + ", " + ParamToStr(idName, decoded.qp) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetInterShapePenaltyINTEL: + { + OpSubgroupAvcMceSetInterShapePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetInterShapePenaltyINTEL(" + ParamToStr(idName, decoded.packedShapePenalty) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL(" + ParamToStr(idName, decoded.sliceType) + ", " + ParamToStr(idName, decoded.qp) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetInterDirectionPenaltyINTEL: + { + OpSubgroupAvcMceSetInterDirectionPenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetInterDirectionPenaltyINTEL(" + ParamToStr(idName, decoded.directionCost) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL(" + ParamToStr(idName, decoded.sliceType) + ", " + ParamToStr(idName, decoded.qp) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: + { + OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL(" + ParamToStr(idName, decoded.sliceType) + ", " + ParamToStr(idName, decoded.qp) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: + { + OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL(" ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: + { + OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL(" ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: + { + OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL(" ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetMotionVectorCostFunctionINTEL: + { + OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetMotionVectorCostFunctionINTEL(" + ParamToStr(idName, decoded.packedCostCenterDelta) + ", " + ParamToStr(idName, decoded.packedCostTable) + ", " + ParamToStr(idName, decoded.costPrecision) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL(" + ParamToStr(idName, decoded.sliceType) + ", " + ParamToStr(idName, decoded.qp) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL(" ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: + { + OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL(" ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetAcOnlyHaarINTEL: + { + OpSubgroupAvcMceSetAcOnlyHaarINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetAcOnlyHaarINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: + { + OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL(" + ParamToStr(idName, decoded.sourceFieldPolarity) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: + { + OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL(" + ParamToStr(idName, decoded.referenceFieldPolarity) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: + { + OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL(" + ParamToStr(idName, decoded.forwardReferenceFieldPolarity) + ", " + ParamToStr(idName, decoded.backwardReferenceFieldPolarity) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceConvertToImePayloadINTEL: + { + OpSubgroupAvcMceConvertToImePayloadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceConvertToImePayloadINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceConvertToImeResultINTEL: + { + OpSubgroupAvcMceConvertToImeResultINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceConvertToImeResultINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceConvertToRefPayloadINTEL: + { + OpSubgroupAvcMceConvertToRefPayloadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceConvertToRefPayloadINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceConvertToRefResultINTEL: + { + OpSubgroupAvcMceConvertToRefResultINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceConvertToRefResultINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceConvertToSicPayloadINTEL: + { + OpSubgroupAvcMceConvertToSicPayloadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceConvertToSicPayloadINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceConvertToSicResultINTEL: + { + OpSubgroupAvcMceConvertToSicResultINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceConvertToSicResultINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetMotionVectorsINTEL: + { + OpSubgroupAvcMceGetMotionVectorsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetMotionVectorsINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterDistortionsINTEL: + { + OpSubgroupAvcMceGetInterDistortionsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterDistortionsINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetBestInterDistortionsINTEL: + { + OpSubgroupAvcMceGetBestInterDistortionsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetBestInterDistortionsINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterMajorShapeINTEL: + { + OpSubgroupAvcMceGetInterMajorShapeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterMajorShapeINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterMinorShapeINTEL: + { + OpSubgroupAvcMceGetInterMinorShapeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterMinorShapeINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterDirectionsINTEL: + { + OpSubgroupAvcMceGetInterDirectionsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterDirectionsINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterMotionVectorCountINTEL: + { + OpSubgroupAvcMceGetInterMotionVectorCountINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterMotionVectorCountINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterReferenceIdsINTEL: + { + OpSubgroupAvcMceGetInterReferenceIdsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterReferenceIdsINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: + { + OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL(" + ParamToStr(idName, decoded.packedReferenceIds) + ", " + ParamToStr(idName, decoded.packedReferenceParameterFieldPolarities) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeInitializeINTEL: + { + OpSubgroupAvcImeInitializeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeInitializeINTEL(" + ParamToStr(idName, decoded.srcCoord) + ", " + ParamToStr(idName, decoded.partitionMask) + ", " + ParamToStr(idName, decoded.sADAdjustment) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeSetSingleReferenceINTEL: + { + OpSubgroupAvcImeSetSingleReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeSetSingleReferenceINTEL(" + ParamToStr(idName, decoded.refOffset) + ", " + ParamToStr(idName, decoded.searchWindowConfig) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeSetDualReferenceINTEL: + { + OpSubgroupAvcImeSetDualReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeSetDualReferenceINTEL(" + ParamToStr(idName, decoded.fwdRefOffset) + ", " + ParamToStr(idName, decoded.bwdRefOffset) + ", " + ParamToStr(idName, decoded.idSearchWindowConfig) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeRefWindowSizeINTEL: + { + OpSubgroupAvcImeRefWindowSizeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeRefWindowSizeINTEL(" + ParamToStr(idName, decoded.searchWindowConfig) + ", " + ParamToStr(idName, decoded.dualRef) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeAdjustRefOffsetINTEL: + { + OpSubgroupAvcImeAdjustRefOffsetINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeAdjustRefOffsetINTEL(" + ParamToStr(idName, decoded.refOffset) + ", " + ParamToStr(idName, decoded.srcCoord) + ", " + ParamToStr(idName, decoded.refWindowSize) + ", " + ParamToStr(idName, decoded.imageSize) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeConvertToMcePayloadINTEL: + { + OpSubgroupAvcImeConvertToMcePayloadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeConvertToMcePayloadINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeSetMaxMotionVectorCountINTEL: + { + OpSubgroupAvcImeSetMaxMotionVectorCountINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeSetMaxMotionVectorCountINTEL(" + ParamToStr(idName, decoded.maxMotionVectorCount) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeSetUnidirectionalMixDisableINTEL: + { + OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeSetUnidirectionalMixDisableINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: + { + OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL(" + ParamToStr(idName, decoded.threshold) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeSetWeightedSadINTEL: + { + OpSubgroupAvcImeSetWeightedSadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeSetWeightedSadINTEL(" + ParamToStr(idName, decoded.packedSadWeights) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceINTEL: + { + OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithSingleReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.refImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceINTEL: + { + OpSubgroupAvcImeEvaluateWithDualReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithDualReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.fwdRefImage) + ", " + ParamToStr(idName, decoded.bwdRefImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: + { + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.refImage) + ", " + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.streaminComponents) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: + { + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.fwdRefImage) + ", " + ParamToStr(idName, decoded.bwdRefImage) + ", " + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.streaminComponents) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: + { + OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.refImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: + { + OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.fwdRefImage) + ", " + ParamToStr(idName, decoded.bwdRefImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: + { + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.refImage) + ", " + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.streaminComponents) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: + { + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.fwdRefImage) + ", " + ParamToStr(idName, decoded.bwdRefImage) + ", " + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.streaminComponents) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeConvertToMceResultINTEL: + { + OpSubgroupAvcImeConvertToMceResultINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeConvertToMceResultINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetSingleReferenceStreaminINTEL: + { + OpSubgroupAvcImeGetSingleReferenceStreaminINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetSingleReferenceStreaminINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetDualReferenceStreaminINTEL: + { + OpSubgroupAvcImeGetDualReferenceStreaminINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetDualReferenceStreaminINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeStripSingleReferenceStreamoutINTEL: + { + OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeStripSingleReferenceStreamoutINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeStripDualReferenceStreamoutINTEL: + { + OpSubgroupAvcImeStripDualReferenceStreamoutINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeStripDualReferenceStreamoutINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: + { + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL(" + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.majorShape) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: + { + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL(" + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.majorShape) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: + { + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL(" + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.majorShape) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: + { + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL(" + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.majorShape) + ", " + ParamToStr(idName, decoded.direction) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: + { + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL(" + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.majorShape) + ", " + ParamToStr(idName, decoded.direction) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: + { + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL(" + ParamToStr(idName, decoded.payload) + ", " + ParamToStr(idName, decoded.majorShape) + ", " + ParamToStr(idName, decoded.direction) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetBorderReachedINTEL: + { + OpSubgroupAvcImeGetBorderReachedINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetBorderReachedINTEL(" + ParamToStr(idName, decoded.imageSelect) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetTruncatedSearchIndicationINTEL: + { + OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetTruncatedSearchIndicationINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: + { + OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: + { + OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: + { + OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcFmeInitializeINTEL: + { + OpSubgroupAvcFmeInitializeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcFmeInitializeINTEL(" + ParamToStr(idName, decoded.srcCoord) + ", " + ParamToStr(idName, decoded.motionVectors) + ", " + ParamToStr(idName, decoded.majorShapes) + ", " + ParamToStr(idName, decoded.minorShapes) + ", " + ParamToStr(idName, decoded.direction) + ", " + ParamToStr(idName, decoded.pixelResolution) + ", " + ParamToStr(idName, decoded.sadAdjustment) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcBmeInitializeINTEL: + { + OpSubgroupAvcBmeInitializeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcBmeInitializeINTEL(" + ParamToStr(idName, decoded.srcCoord) + ", " + ParamToStr(idName, decoded.motionVectors) + ", " + ParamToStr(idName, decoded.majorShapes) + ", " + ParamToStr(idName, decoded.minorShapes) + ", " + ParamToStr(idName, decoded.direction) + ", " + ParamToStr(idName, decoded.pixelResolution) + ", " + ParamToStr(idName, decoded.bidirectionalWeight) + ", " + ParamToStr(idName, decoded.sadAdjustment) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefConvertToMcePayloadINTEL: + { + OpSubgroupAvcRefConvertToMcePayloadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefConvertToMcePayloadINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefSetBidirectionalMixDisableINTEL: + { + OpSubgroupAvcRefSetBidirectionalMixDisableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefSetBidirectionalMixDisableINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefSetBilinearFilterEnableINTEL: + { + OpSubgroupAvcRefSetBilinearFilterEnableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefSetBilinearFilterEnableINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefEvaluateWithSingleReferenceINTEL: + { + OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefEvaluateWithSingleReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.refImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefEvaluateWithDualReferenceINTEL: + { + OpSubgroupAvcRefEvaluateWithDualReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefEvaluateWithDualReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.fwdRefImage) + ", " + ParamToStr(idName, decoded.bwdRefImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefEvaluateWithMultiReferenceINTEL: + { + OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefEvaluateWithMultiReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.packedReferenceIds) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: + { + OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.packedReferenceIds) + ", " + ParamToStr(idName, decoded.packedReferenceFieldPolarities) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcRefConvertToMceResultINTEL: + { + OpSubgroupAvcRefConvertToMceResultINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcRefConvertToMceResultINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicInitializeINTEL: + { + OpSubgroupAvcSicInitializeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicInitializeINTEL(" + ParamToStr(idName, decoded.srcCoord) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicConfigureSkcINTEL: + { + OpSubgroupAvcSicConfigureSkcINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicConfigureSkcINTEL(" + ParamToStr(idName, decoded.skipBlockPartitionType) + ", " + ParamToStr(idName, decoded.skipMotionVectorMask) + ", " + ParamToStr(idName, decoded.motionVectors) + ", " + ParamToStr(idName, decoded.bidirectionalWeight) + ", " + ParamToStr(idName, decoded.sadAdjustment) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicConfigureIpeLumaINTEL: + { + OpSubgroupAvcSicConfigureIpeLumaINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicConfigureIpeLumaINTEL(" + ParamToStr(idName, decoded.lumaIntraPartitionMask) + ", " + ParamToStr(idName, decoded.intraNeighbourAvailabilty) + ", " + ParamToStr(idName, decoded.leftEdgeLumaPixels) + ", " + ParamToStr(idName, decoded.upperLeftCornerLumaPixel) + ", " + ParamToStr(idName, decoded.upperEdgeLumaPixels) + ", " + ParamToStr(idName, decoded.upperRightEdgeLumaPixels) + ", " + ParamToStr(idName, decoded.sadAdjustment) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicConfigureIpeLumaChromaINTEL: + { + OpSubgroupAvcSicConfigureIpeLumaChromaINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicConfigureIpeLumaChromaINTEL(" + ParamToStr(idName, decoded.lumaIntraPartitionMask) + ", " + ParamToStr(idName, decoded.intraNeighbourAvailabilty) + ", " + ParamToStr(idName, decoded.leftEdgeLumaPixels) + ", " + ParamToStr(idName, decoded.upperLeftCornerLumaPixel) + ", " + ParamToStr(idName, decoded.upperEdgeLumaPixels) + ", " + ParamToStr(idName, decoded.upperRightEdgeLumaPixels) + ", " + ParamToStr(idName, decoded.leftEdgeChromaPixels) + ", " + ParamToStr(idName, decoded.upperLeftCornerChromaPixel) + ", " + ParamToStr(idName, decoded.upperEdgeChromaPixels) + ", " + ParamToStr(idName, decoded.sadAdjustment) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetMotionVectorMaskINTEL: + { + OpSubgroupAvcSicGetMotionVectorMaskINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetMotionVectorMaskINTEL(" + ParamToStr(idName, decoded.skipBlockPartitionType) + ", " + ParamToStr(idName, decoded.direction) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicConvertToMcePayloadINTEL: + { + OpSubgroupAvcSicConvertToMcePayloadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicConvertToMcePayloadINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicSetIntraLumaShapePenaltyINTEL: + { + OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicSetIntraLumaShapePenaltyINTEL(" + ParamToStr(idName, decoded.packedShapePenalty) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: + { + OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL(" + ParamToStr(idName, decoded.lumaModePenalty) + ", " + ParamToStr(idName, decoded.lumaPackedNeighborModes) + ", " + ParamToStr(idName, decoded.lumaPackedNonDcPenalty) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: + { + OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL(" + ParamToStr(idName, decoded.chromaModeBasePenalty) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicSetBilinearFilterEnableINTEL: + { + OpSubgroupAvcSicSetBilinearFilterEnableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicSetBilinearFilterEnableINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicSetSkcForwardTransformEnableINTEL: + { + OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicSetSkcForwardTransformEnableINTEL(" + ParamToStr(idName, decoded.packedSadCoefficients) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicSetBlockBasedRawSkipSadINTEL: + { + OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicSetBlockBasedRawSkipSadINTEL(" + ParamToStr(idName, decoded.blockBasedSkipType) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicEvaluateIpeINTEL: + { + OpSubgroupAvcSicEvaluateIpeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicEvaluateIpeINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicEvaluateWithSingleReferenceINTEL: + { + OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicEvaluateWithSingleReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.refImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicEvaluateWithDualReferenceINTEL: + { + OpSubgroupAvcSicEvaluateWithDualReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicEvaluateWithDualReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.fwdRefImage) + ", " + ParamToStr(idName, decoded.bwdRefImage) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicEvaluateWithMultiReferenceINTEL: + { + OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicEvaluateWithMultiReferenceINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.packedReferenceIds) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: + { + OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL(" + ParamToStr(idName, decoded.srcImage) + ", " + ParamToStr(idName, decoded.packedReferenceIds) + ", " + ParamToStr(idName, decoded.packedReferenceFieldPolarities) + ", " + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicConvertToMceResultINTEL: + { + OpSubgroupAvcSicConvertToMceResultINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicConvertToMceResultINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetIpeLumaShapeINTEL: + { + OpSubgroupAvcSicGetIpeLumaShapeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetIpeLumaShapeINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetBestIpeLumaDistortionINTEL: + { + OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetBestIpeLumaDistortionINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetBestIpeChromaDistortionINTEL: + { + OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetBestIpeChromaDistortionINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetPackedIpeLumaModesINTEL: + { + OpSubgroupAvcSicGetPackedIpeLumaModesINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetPackedIpeLumaModesINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetIpeChromaModeINTEL: + { + OpSubgroupAvcSicGetIpeChromaModeINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetIpeChromaModeINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: + { + OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: + { + OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case rdcspv::Op::SubgroupAvcSicGetInterRawSadsINTEL: + { + OpSubgroupAvcSicGetInterRawSadsINTEL decoded(it); + ret += declName(decoded.resultType, decoded.result) + " = "; + ret += "SubgroupAvcSicGetInterRawSadsINTEL(" + ParamToStr(idName, decoded.payload) + ")"; + break; + } + case Op::Max: break; + } + return ret; +} + +OpDecoder::OpDecoder(const ConstIter &it) +{ + op = (rdcspv::Op)it.opcode(); + wordCount = (uint16_t)it.size(); + switch(op) + { + case rdcspv::Op::Nop: result = Id(); resultType = Id(); break; + case rdcspv::Op::Undef: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SourceContinued: result = Id(); resultType = Id(); break; + case rdcspv::Op::Source: result = Id(); resultType = Id(); break; + case rdcspv::Op::SourceExtension: result = Id(); resultType = Id(); break; + case rdcspv::Op::Name: result = Id(); resultType = Id(); break; + case rdcspv::Op::MemberName: result = Id(); resultType = Id(); break; + case rdcspv::Op::String: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::Line: result = Id(); resultType = Id(); break; + case rdcspv::Op::Extension: result = Id(); resultType = Id(); break; + case rdcspv::Op::ExtInstImport: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::ExtInst: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::MemoryModel: result = Id(); resultType = Id(); break; + case rdcspv::Op::EntryPoint: result = Id(); resultType = Id(); break; + case rdcspv::Op::ExecutionMode: result = Id(); resultType = Id(); break; + case rdcspv::Op::Capability: result = Id(); resultType = Id(); break; + case rdcspv::Op::TypeVoid: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeBool: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeInt: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeFloat: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeVector: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeMatrix: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeImage: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeSampler: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeSampledImage: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeArray: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeRuntimeArray: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeStruct: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeOpaque: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypePointer: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeFunction: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeEvent: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeDeviceEvent: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeReserveId: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeQueue: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypePipe: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeForwardPointer: result = Id(); resultType = Id(); break; + case rdcspv::Op::ConstantTrue: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConstantFalse: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Constant: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConstantComposite: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConstantSampler: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConstantNull: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SpecConstantTrue: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SpecConstantFalse: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SpecConstant: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SpecConstantComposite: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SpecConstantOp: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Function: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FunctionParameter: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FunctionEnd: result = Id(); resultType = Id(); break; + case rdcspv::Op::FunctionCall: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Variable: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageTexelPointer: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Load: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Store: result = Id(); resultType = Id(); break; + case rdcspv::Op::CopyMemory: result = Id(); resultType = Id(); break; + case rdcspv::Op::CopyMemorySized: result = Id(); resultType = Id(); break; + case rdcspv::Op::AccessChain: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::InBoundsAccessChain: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::PtrAccessChain: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ArrayLength: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GenericPtrMemSemantics: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::InBoundsPtrAccessChain: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Decorate: result = Id(); resultType = Id(); break; + case rdcspv::Op::MemberDecorate: result = Id(); resultType = Id(); break; + case rdcspv::Op::DecorationGroup: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::GroupDecorate: result = Id(); resultType = Id(); break; + case rdcspv::Op::GroupMemberDecorate: result = Id(); resultType = Id(); break; + case rdcspv::Op::VectorExtractDynamic: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::VectorInsertDynamic: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::VectorShuffle: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CompositeConstruct: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CompositeExtract: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CompositeInsert: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CopyObject: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Transpose: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SampledImage: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleDrefImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleDrefExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleProjImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleProjExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleProjDrefImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleProjDrefExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageFetch: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageGather: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageDrefGather: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageRead: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageWrite: result = Id(); resultType = Id(); break; + case rdcspv::Op::Image: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQueryFormat: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQueryOrder: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQuerySizeLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQuerySize: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQueryLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQueryLevels: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageQuerySamples: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConvertFToU: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConvertFToS: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConvertSToF: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConvertUToF: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UConvert: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SConvert: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FConvert: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::QuantizeToF16: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConvertPtrToU: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SatConvertSToU: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SatConvertUToS: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ConvertUToPtr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::PtrCastToGeneric: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GenericCastToPtr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GenericCastToPtrExplicit: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Bitcast: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SNegate: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FNegate: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ISub: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FSub: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IMul: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FMul: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UDiv: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SDiv: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FDiv: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UMod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SRem: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SMod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FRem: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FMod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::VectorTimesScalar: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::MatrixTimesScalar: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::VectorTimesMatrix: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::MatrixTimesVector: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::MatrixTimesMatrix: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::OuterProduct: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Dot: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IAddCarry: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ISubBorrow: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UMulExtended: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SMulExtended: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Any: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::All: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IsNan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IsInf: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IsFinite: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IsNormal: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SignBitSet: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LessOrGreater: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Ordered: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Unordered: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LogicalEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LogicalNotEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LogicalOr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LogicalAnd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LogicalNot: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Select: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::INotEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UGreaterThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SGreaterThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UGreaterThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SGreaterThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ULessThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SLessThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ULessThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SLessThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FOrdEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FUnordEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FOrdNotEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FUnordNotEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FOrdLessThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FUnordLessThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FOrdGreaterThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FUnordGreaterThan: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FOrdLessThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FUnordLessThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FOrdGreaterThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FUnordGreaterThanEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ShiftRightLogical: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ShiftRightArithmetic: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ShiftLeftLogical: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitwiseOr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitwiseXor: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitwiseAnd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Not: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitFieldInsert: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitFieldSExtract: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitFieldUExtract: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitReverse: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BitCount: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DPdx: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DPdy: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Fwidth: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DPdxFine: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DPdyFine: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FwidthFine: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DPdxCoarse: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DPdyCoarse: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FwidthCoarse: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::EmitVertex: result = Id(); resultType = Id(); break; + case rdcspv::Op::EndPrimitive: result = Id(); resultType = Id(); break; + case rdcspv::Op::EmitStreamVertex: result = Id(); resultType = Id(); break; + case rdcspv::Op::EndStreamPrimitive: result = Id(); resultType = Id(); break; + case rdcspv::Op::ControlBarrier: result = Id(); resultType = Id(); break; + case rdcspv::Op::MemoryBarrier: result = Id(); resultType = Id(); break; + case rdcspv::Op::AtomicLoad: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicStore: result = Id(); resultType = Id(); break; + case rdcspv::Op::AtomicExchange: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicCompareExchange: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicCompareExchangeWeak: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicIIncrement: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicIDecrement: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicIAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicISub: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicSMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicUMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicSMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicUMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicAnd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicOr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicXor: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::Phi: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::LoopMerge: result = Id(); resultType = Id(); break; + case rdcspv::Op::SelectionMerge: result = Id(); resultType = Id(); break; + case rdcspv::Op::Label: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::Branch: result = Id(); resultType = Id(); break; + case rdcspv::Op::BranchConditional: result = Id(); resultType = Id(); break; + case rdcspv::Op::Switch: result = Id(); resultType = Id(); break; + case rdcspv::Op::Kill: result = Id(); resultType = Id(); break; + case rdcspv::Op::Return: result = Id(); resultType = Id(); break; + case rdcspv::Op::ReturnValue: result = Id(); resultType = Id(); break; + case rdcspv::Op::Unreachable: result = Id(); resultType = Id(); break; + case rdcspv::Op::LifetimeStart: result = Id(); resultType = Id(); break; + case rdcspv::Op::LifetimeStop: result = Id(); resultType = Id(); break; + case rdcspv::Op::GroupAsyncCopy: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupWaitEvents: result = Id(); resultType = Id(); break; + case rdcspv::Op::GroupAll: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupAny: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupBroadcast: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupIAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupFAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupFMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupUMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupSMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupFMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupUMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupSMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ReadPipe: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::WritePipe: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ReservedReadPipe: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ReservedWritePipe: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ReserveReadPipePackets: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ReserveWritePipePackets: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CommitReadPipe: result = Id(); resultType = Id(); break; + case rdcspv::Op::CommitWritePipe: result = Id(); resultType = Id(); break; + case rdcspv::Op::IsValidReserveId: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetNumPipePackets: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetMaxPipePackets: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupReserveReadPipePackets: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupReserveWritePipePackets: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupCommitReadPipe: result = Id(); resultType = Id(); break; + case rdcspv::Op::GroupCommitWritePipe: result = Id(); resultType = Id(); break; + case rdcspv::Op::EnqueueMarker: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::EnqueueKernel: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetKernelNDrangeSubGroupCount: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetKernelNDrangeMaxSubGroupSize: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetKernelWorkGroupSize: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetKernelPreferredWorkGroupSizeMultiple: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::RetainEvent: result = Id(); resultType = Id(); break; + case rdcspv::Op::ReleaseEvent: result = Id(); resultType = Id(); break; + case rdcspv::Op::CreateUserEvent: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IsValidEvent: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SetUserEventStatus: result = Id(); resultType = Id(); break; + case rdcspv::Op::CaptureEventProfilingInfo: result = Id(); resultType = Id(); break; + case rdcspv::Op::GetDefaultQueue: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BuildNDRange: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleDrefImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleDrefExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleProjImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleProjExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleProjDrefImplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseSampleProjDrefExplicitLod: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseFetch: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseGather: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseDrefGather: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSparseTexelsResident: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::NoLine: result = Id(); resultType = Id(); break; + case rdcspv::Op::AtomicFlagTestAndSet: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AtomicFlagClear: result = Id(); resultType = Id(); break; + case rdcspv::Op::ImageSparseRead: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SizeOf: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::TypePipeStorage: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::ConstantPipeStorage: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CreatePipeFromPipeStorage: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetKernelLocalSizeForSubgroupCount: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GetKernelMaxNumSubgroups: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::TypeNamedBarrier: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::NamedBarrierInitialize: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::MemoryNamedBarrier: result = Id(); resultType = Id(); break; + case rdcspv::Op::ModuleProcessed: result = Id(); resultType = Id(); break; + case rdcspv::Op::ExecutionModeId: result = Id(); resultType = Id(); break; + case rdcspv::Op::DecorateId: result = Id(); resultType = Id(); break; + case rdcspv::Op::GroupNonUniformElect: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformAll: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformAny: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformAllEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBroadcast: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBroadcastFirst: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBallot: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformInverseBallot: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBallotBitExtract: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBallotBitCount: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBallotFindLSB: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBallotFindMSB: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformShuffle: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformShuffleXor: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformShuffleUp: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformShuffleDown: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformIAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformFAdd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformIMul: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformFMul: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformSMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformUMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformFMin: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformSMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformUMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformFMax: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBitwiseAnd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBitwiseOr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformBitwiseXor: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformLogicalAnd: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformLogicalOr: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformLogicalXor: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformQuadBroadcast: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformQuadSwap: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CopyLogical: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::PtrEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::PtrNotEqual: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::PtrDiff: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupBallotKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupFirstInvocationKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAllKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAnyKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAllEqualKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupReadInvocationKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupIAddNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupFAddNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupFMinNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupUMinNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupSMinNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupFMaxNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupUMaxNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupSMaxNonUniformAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FragmentMaskFetchAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::FragmentFetchAMD: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ReadClockKHR: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ImageSampleFootprintNV: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::GroupNonUniformPartitionNV: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::WritePackedPrimitiveIndices4x8NV: result = Id(); resultType = Id(); break; + case rdcspv::Op::ReportIntersectionNV: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IgnoreIntersectionNV: result = Id(); resultType = Id(); break; + case rdcspv::Op::TerminateRayNV: result = Id(); resultType = Id(); break; + case rdcspv::Op::TraceNV: result = Id(); resultType = Id(); break; + case rdcspv::Op::TypeAccelerationStructureNV: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::ExecuteCallableNV: result = Id(); resultType = Id(); break; + case rdcspv::Op::TypeCooperativeMatrixNV: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::CooperativeMatrixLoadNV: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CooperativeMatrixStoreNV: result = Id(); resultType = Id(); break; + case rdcspv::Op::CooperativeMatrixMulAddNV: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::CooperativeMatrixLengthNV: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::BeginInvocationInterlockEXT: result = Id(); resultType = Id(); break; + case rdcspv::Op::EndInvocationInterlockEXT: result = Id(); resultType = Id(); break; + case rdcspv::Op::DemoteToHelperInvocationEXT: result = Id(); resultType = Id(); break; + case rdcspv::Op::IsHelperInvocationEXT: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupShuffleINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupShuffleDownINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupShuffleUpINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupShuffleXorINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupBlockReadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupBlockWriteINTEL: result = Id(); resultType = Id(); break; + case rdcspv::Op::SubgroupImageBlockReadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupImageBlockWriteINTEL: result = Id(); resultType = Id(); break; + case rdcspv::Op::SubgroupImageMediaBlockReadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupImageMediaBlockWriteINTEL: result = Id(); resultType = Id(); break; + case rdcspv::Op::UCountLeadingZerosINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UCountTrailingZerosINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AbsISubINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::AbsUSubINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IAddSatINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UAddSatINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IAverageINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UAverageINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IAverageRoundedINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UAverageRoundedINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::ISubSatINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::USubSatINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::IMul32x16INTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::UMul32x16INTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::DecorateString: result = Id(); resultType = Id(); break; + case rdcspv::Op::MemberDecorateString: result = Id(); resultType = Id(); break; + case rdcspv::Op::VmeImageINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::TypeVmeImageINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcImePayloadINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcRefPayloadINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcSicPayloadINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcMcePayloadINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcMceResultINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcImeResultINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcImeResultSingleReferenceStreamoutINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcImeResultDualReferenceStreamoutINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcImeSingleReferenceStreaminINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcImeDualReferenceStreaminINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcRefResultINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::TypeAvcSicResultINTEL: result = Id::fromWord(it.word(1)); resultType = Id(); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterShapePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetInterShapePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetInterDirectionPenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetMotionVectorCostFunctionINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetAcOnlyHaarINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceConvertToImePayloadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceConvertToImeResultINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceConvertToRefPayloadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceConvertToRefResultINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceConvertToSicPayloadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceConvertToSicResultINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetMotionVectorsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterDistortionsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetBestInterDistortionsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterMajorShapeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterMinorShapeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterDirectionsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterMotionVectorCountINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterReferenceIdsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeInitializeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeSetSingleReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeSetDualReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeRefWindowSizeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeAdjustRefOffsetINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeConvertToMcePayloadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeSetMaxMotionVectorCountINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeSetUnidirectionalMixDisableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeSetWeightedSadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeConvertToMceResultINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetSingleReferenceStreaminINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetDualReferenceStreaminINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeStripSingleReferenceStreamoutINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeStripDualReferenceStreamoutINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetBorderReachedINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetTruncatedSearchIndicationINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcFmeInitializeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcBmeInitializeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefConvertToMcePayloadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefSetBidirectionalMixDisableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefSetBilinearFilterEnableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithSingleReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithDualReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithMultiReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcRefConvertToMceResultINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicInitializeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicConfigureSkcINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicConfigureIpeLumaINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicConfigureIpeLumaChromaINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetMotionVectorMaskINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicConvertToMcePayloadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicSetIntraLumaShapePenaltyINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicSetBilinearFilterEnableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicSetSkcForwardTransformEnableINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicSetBlockBasedRawSkipSadINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicEvaluateIpeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithSingleReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithDualReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithMultiReferenceINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicConvertToMceResultINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetIpeLumaShapeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetBestIpeLumaDistortionINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetBestIpeChromaDistortionINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetPackedIpeLumaModesINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetIpeChromaModeINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case rdcspv::Op::SubgroupAvcSicGetInterRawSadsINTEL: result = Id::fromWord(it.word(2)); resultType = Id::fromWord(it.word(1)); break; + case Op::Max: break; + } +} + +}; // namespace rdcspv + +template <> +rdcstr DoStringise(const rdcspv::GLSLstd450 &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::GLSLstd450); + { + STRINGISE_ENUM_CLASS(Round); + STRINGISE_ENUM_CLASS(RoundEven); + STRINGISE_ENUM_CLASS(Trunc); + STRINGISE_ENUM_CLASS(FAbs); + STRINGISE_ENUM_CLASS(SAbs); + STRINGISE_ENUM_CLASS(FSign); + STRINGISE_ENUM_CLASS(SSign); + STRINGISE_ENUM_CLASS(Floor); + STRINGISE_ENUM_CLASS(Ceil); + STRINGISE_ENUM_CLASS(Fract); + STRINGISE_ENUM_CLASS(Radians); + STRINGISE_ENUM_CLASS(Degrees); + STRINGISE_ENUM_CLASS(Sin); + STRINGISE_ENUM_CLASS(Cos); + STRINGISE_ENUM_CLASS(Tan); + STRINGISE_ENUM_CLASS(Asin); + STRINGISE_ENUM_CLASS(Acos); + STRINGISE_ENUM_CLASS(Atan); + STRINGISE_ENUM_CLASS(Sinh); + STRINGISE_ENUM_CLASS(Cosh); + STRINGISE_ENUM_CLASS(Tanh); + STRINGISE_ENUM_CLASS(Asinh); + STRINGISE_ENUM_CLASS(Acosh); + STRINGISE_ENUM_CLASS(Atanh); + STRINGISE_ENUM_CLASS(Atan2); + STRINGISE_ENUM_CLASS(Pow); + STRINGISE_ENUM_CLASS(Exp); + STRINGISE_ENUM_CLASS(Log); + STRINGISE_ENUM_CLASS(Exp2); + STRINGISE_ENUM_CLASS(Log2); + STRINGISE_ENUM_CLASS(Sqrt); + STRINGISE_ENUM_CLASS(InverseSqrt); + STRINGISE_ENUM_CLASS(Determinant); + STRINGISE_ENUM_CLASS(MatrixInverse); + STRINGISE_ENUM_CLASS(Modf); + STRINGISE_ENUM_CLASS(ModfStruct); + STRINGISE_ENUM_CLASS(FMin); + STRINGISE_ENUM_CLASS(UMin); + STRINGISE_ENUM_CLASS(SMin); + STRINGISE_ENUM_CLASS(FMax); + STRINGISE_ENUM_CLASS(UMax); + STRINGISE_ENUM_CLASS(SMax); + STRINGISE_ENUM_CLASS(FClamp); + STRINGISE_ENUM_CLASS(UClamp); + STRINGISE_ENUM_CLASS(SClamp); + STRINGISE_ENUM_CLASS(FMix); + STRINGISE_ENUM_CLASS(IMix); + STRINGISE_ENUM_CLASS(Step); + STRINGISE_ENUM_CLASS(SmoothStep); + STRINGISE_ENUM_CLASS(Fma); + STRINGISE_ENUM_CLASS(Frexp); + STRINGISE_ENUM_CLASS(FrexpStruct); + STRINGISE_ENUM_CLASS(Ldexp); + STRINGISE_ENUM_CLASS(PackSnorm4x8); + STRINGISE_ENUM_CLASS(PackUnorm4x8); + STRINGISE_ENUM_CLASS(PackSnorm2x16); + STRINGISE_ENUM_CLASS(PackUnorm2x16); + STRINGISE_ENUM_CLASS(PackHalf2x16); + STRINGISE_ENUM_CLASS(PackDouble2x32); + STRINGISE_ENUM_CLASS(UnpackSnorm2x16); + STRINGISE_ENUM_CLASS(UnpackUnorm2x16); + STRINGISE_ENUM_CLASS(UnpackHalf2x16); + STRINGISE_ENUM_CLASS(UnpackSnorm4x8); + STRINGISE_ENUM_CLASS(UnpackUnorm4x8); + STRINGISE_ENUM_CLASS(UnpackDouble2x32); + STRINGISE_ENUM_CLASS(Length); + STRINGISE_ENUM_CLASS(Distance); + STRINGISE_ENUM_CLASS(Cross); + STRINGISE_ENUM_CLASS(Normalize); + STRINGISE_ENUM_CLASS(FaceForward); + STRINGISE_ENUM_CLASS(Reflect); + STRINGISE_ENUM_CLASS(Refract); + STRINGISE_ENUM_CLASS(FindILsb); + STRINGISE_ENUM_CLASS(FindSMsb); + STRINGISE_ENUM_CLASS(FindUMsb); + STRINGISE_ENUM_CLASS(InterpolateAtCentroid); + STRINGISE_ENUM_CLASS(InterpolateAtSample); + STRINGISE_ENUM_CLASS(InterpolateAtOffset); + STRINGISE_ENUM_CLASS(NMin); + STRINGISE_ENUM_CLASS(NMax); + STRINGISE_ENUM_CLASS(NClamp); + } + END_ENUM_STRINGISE(); +} + +template <> +rdcstr DoStringise(const rdcspv::Generator &el) +{ + BEGIN_ENUM_STRINGISE(rdcspv::Generator); + { + STRINGISE_ENUM_CLASS_NAMED(LLVMSPIRVTranslator, "LLVM/SPIR-V Translator from Khronos - Contact Yaxun (Sam) Liu, yaxun.liu@amd.com"); + STRINGISE_ENUM_CLASS_NAMED(SPIRVToolsAssembler, "SPIR-V Tools Assembler from Khronos - Contact David Neto, dneto@google.com"); + STRINGISE_ENUM_CLASS_NAMED(GlslangReferenceFrontEnd, "Glslang Reference Front End from Khronos - Contact John Kessenich, johnkessenich@google.com"); + STRINGISE_ENUM_CLASS_NAMED(ShadercoverGlslang, "Shaderc over Glslang from Google - Contact David Neto, dneto@google.com"); + STRINGISE_ENUM_CLASS_NAMED(spiregg, "spiregg from Google - Contact Lei Zhang, antiagainst@google.com"); + STRINGISE_ENUM_CLASS_NAMED(rspirv, "rspirv from Google - Contact Lei Zhang, antiagainst@gmail.com"); + STRINGISE_ENUM_CLASS_NAMED(MesaIRSPIRVTranslator, "Mesa-IR/SPIR-V Translator from X-LEGEND - Contact Metora Wang, github:metora/MesaGLSLCompiler"); + STRINGISE_ENUM_CLASS_NAMED(SPIRVToolsLinker, "SPIR-V Tools Linker from Khronos - Contact David Neto, dneto@google.com"); + STRINGISE_ENUM_CLASS_NAMED(VKD3DShaderCompiler, "VKD3D Shader Compiler from Wine - Contact wine-devel@winehq.org"); + STRINGISE_ENUM_CLASS_NAMED(ClayShaderCompiler, "Clay Shader Compiler from Clay - Contact info@clayengine.com"); + STRINGISE_ENUM_CLASS_NAMED(WHLSLShaderTranslator, "WHLSL Shader Translator from W3C WebGPU Group - https://github.com/gpuweb/WHLSL"); + STRINGISE_ENUM_CLASS_NAMED(Clspv, "Clspv from Google - Contact David Neto, dneto@google.com"); + STRINGISE_ENUM_CLASS_NAMED(MLIRSPIRVSerializer, "MLIR SPIR-V Serializer from Google - Contact Lei Zhang, antiagainst@google.com"); + } + END_ENUM_STRINGISE(); +} diff --git a/renderdoc/driver/shaders/spirv/spirv_gen.h b/renderdoc/driver/shaders/spirv/spirv_gen.h new file mode 100644 index 000000000..fa9f20b06 --- /dev/null +++ b/renderdoc/driver/shaders/spirv/spirv_gen.h @@ -0,0 +1,1778 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2019 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +/****************************************************************************** + * Generated from Khronos SPIR-V machine-readable JSON grammar. + * + * Copyright (c) 2014-2016 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and/or associated documentation files (the "Materials"), + * to deal in the Materials without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Materials, and to permit persons to whom the + * Materials are furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Materials. + * + * MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS + * STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND + * HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS + * IN THE MATERIALS. + ******************************************************************************/ + +#pragma once + +// This file is autogenerated with gen_spirv_code.py - any changes will be overwritten next time +// that script is run. +// $ ./gen_spirv_code.py + +// We need to disable clang-format since this file is programmatically generated +// clang-format off + +#include +#include "api/replay/renderdoc_replay.h" + +#undef None +#undef CopyMemory +#undef MemoryBarrier + +namespace rdcspv +{ +static const uint32_t MagicNumber = 0x07230203; +static const uint32_t VersionMajor = 1; +static const uint32_t VersionMinor = 4; +static const uint32_t VersionRevision = 1; +static const uint32_t VersionPacked = (1 << 16) | (4 << 8); +static const uint32_t OpCodeMask = 0xffff; +static const uint32_t WordCountShift = 16; +static const uint32_t FirstRealWord = 5; + +struct Id +{ + constexpr inline Id() : id(0) {} + // only allow explicit functions to cast to/from uint32_t + constexpr static inline Id fromWord(uint32_t i) { return Id(i); } + inline uint32_t value() const { return id; } + constexpr inline explicit operator bool() const { return id != 0; } + constexpr inline bool operator==(const Id o) const { return id == o.id; } + constexpr inline bool operator!=(const Id o) const { return id != o.id; } + constexpr inline bool operator<(const Id o) const { return id < o.id; } + constexpr inline bool operator==(const uint32_t o) const { return id == o; } + constexpr inline bool operator!=(const uint32_t o) const { return id != o; } + constexpr inline bool operator<(const uint32_t o) const { return id < o; } +private: + constexpr inline Id(uint32_t i) : id(i) {} + uint32_t id; +}; + +enum class Generator : uint32_t +{ + LLVMSPIRVTranslator = 6, + SPIRVToolsAssembler = 7, + GlslangReferenceFrontEnd = 8, + ShadercoverGlslang = 13, + spiregg = 14, + rspirv = 15, + MesaIRSPIRVTranslator = 16, + SPIRVToolsLinker = 17, + VKD3DShaderCompiler = 18, + ClayShaderCompiler = 19, + WHLSLShaderTranslator = 20, + Clspv = 21, + MLIRSPIRVSerializer = 22, +}; + +enum class ImageOperands : uint32_t +{ + None = 0x0000, + Bias = 0x0001, + Lod = 0x0002, + Grad = 0x0004, + ConstOffset = 0x0008, + Offset = 0x0010, + ConstOffsets = 0x0020, + Sample = 0x0040, + MinLod = 0x0080, + MakeTexelAvailableKHR = 0x0100, + MakeTexelVisibleKHR = 0x0200, + NonPrivateTexelKHR = 0x0400, + VolatileTexelKHR = 0x0800, + SignExtend = 0x1000, + ZeroExtend = 0x2000, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(ImageOperands); + +enum class FPFastMathMode : uint32_t +{ + None = 0x0000, + NotNaN = 0x0001, + NotInf = 0x0002, + NSZ = 0x0004, + AllowRecip = 0x0008, + Fast = 0x0010, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(FPFastMathMode); + +enum class SelectionControl : uint32_t +{ + None = 0x0000, + Flatten = 0x0001, + DontFlatten = 0x0002, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(SelectionControl); + +enum class LoopControl : uint32_t +{ + None = 0x0000, + Unroll = 0x0001, + DontUnroll = 0x0002, + DependencyInfinite = 0x0004, + DependencyLength = 0x0008, + MinIterations = 0x0010, + MaxIterations = 0x0020, + IterationMultiple = 0x0040, + PeelCount = 0x0080, + PartialCount = 0x0100, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(LoopControl); + +enum class FunctionControl : uint32_t +{ + None = 0x0000, + Inline = 0x0001, + DontInline = 0x0002, + Pure = 0x0004, + Const = 0x0008, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(FunctionControl); + +enum class MemorySemantics : uint32_t +{ + Relaxed = 0x0000, + None = 0x0000, + Acquire = 0x0002, + Release = 0x0004, + AcquireRelease = 0x0008, + SequentiallyConsistent = 0x0010, + UniformMemory = 0x0040, + SubgroupMemory = 0x0080, + WorkgroupMemory = 0x0100, + CrossWorkgroupMemory = 0x0200, + AtomicCounterMemory = 0x0400, + ImageMemory = 0x0800, + OutputMemoryKHR = 0x1000, + MakeAvailableKHR = 0x2000, + MakeVisibleKHR = 0x4000, + Volatile = 0x8000, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(MemorySemantics); + +enum class MemoryAccess : uint32_t +{ + None = 0x0000, + Volatile = 0x0001, + Aligned = 0x0002, + Nontemporal = 0x0004, + MakePointerAvailableKHR = 0x0008, + MakePointerVisibleKHR = 0x0010, + NonPrivatePointerKHR = 0x0020, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(MemoryAccess); + +enum class KernelProfilingInfo : uint32_t +{ + None = 0x0000, + CmdExecTime = 0x0001, + Max, + Invalid = ~0U, +}; + +BITMASK_OPERATORS(KernelProfilingInfo); + +enum class SourceLanguage : uint32_t +{ + Unknown = 0, + ESSL = 1, + GLSL = 2, + OpenCL_C = 3, + OpenCL_CPP = 4, + HLSL = 5, + Max, + Invalid = ~0U, +}; + +enum class ExecutionModel : uint32_t +{ + Vertex = 0, + TessellationControl = 1, + TessellationEvaluation = 2, + Geometry = 3, + Fragment = 4, + GLCompute = 5, + Kernel = 6, + TaskNV = 5267, + MeshNV = 5268, + RayGenerationNV = 5313, + IntersectionNV = 5314, + AnyHitNV = 5315, + ClosestHitNV = 5316, + MissNV = 5317, + CallableNV = 5318, + Max, + Invalid = ~0U, +}; + +enum class AddressingModel : uint32_t +{ + Logical = 0, + Physical32 = 1, + Physical64 = 2, + PhysicalStorageBuffer64EXT = 5348, + Max, + Invalid = ~0U, +}; + +enum class MemoryModel : uint32_t +{ + Simple = 0, + GLSL450 = 1, + OpenCL = 2, + VulkanKHR = 3, + Max, + Invalid = ~0U, +}; + +enum class ExecutionMode : uint32_t +{ + Invocations = 0, + SpacingEqual = 1, + SpacingFractionalEven = 2, + SpacingFractionalOdd = 3, + VertexOrderCw = 4, + VertexOrderCcw = 5, + PixelCenterInteger = 6, + OriginUpperLeft = 7, + OriginLowerLeft = 8, + EarlyFragmentTests = 9, + PointMode = 10, + Xfb = 11, + DepthReplacing = 12, + DepthGreater = 14, + DepthLess = 15, + DepthUnchanged = 16, + LocalSize = 17, + LocalSizeHint = 18, + InputPoints = 19, + InputLines = 20, + InputLinesAdjacency = 21, + Triangles = 22, + InputTrianglesAdjacency = 23, + Quads = 24, + Isolines = 25, + OutputVertices = 26, + OutputPoints = 27, + OutputLineStrip = 28, + OutputTriangleStrip = 29, + VecTypeHint = 30, + ContractionOff = 31, + Initializer = 33, + Finalizer = 34, + SubgroupSize = 35, + SubgroupsPerWorkgroup = 36, + SubgroupsPerWorkgroupId = 37, + LocalSizeId = 38, + LocalSizeHintId = 39, + PostDepthCoverage = 4446, + DenormPreserve = 4459, + DenormFlushToZero = 4460, + SignedZeroInfNanPreserve = 4461, + RoundingModeRTE = 4462, + RoundingModeRTZ = 4463, + StencilRefReplacingEXT = 5027, + OutputLinesNV = 5269, + OutputPrimitivesNV = 5270, + DerivativeGroupQuadsNV = 5289, + DerivativeGroupLinearNV = 5290, + OutputTrianglesNV = 5298, + PixelInterlockOrderedEXT = 5366, + PixelInterlockUnorderedEXT = 5367, + SampleInterlockOrderedEXT = 5368, + SampleInterlockUnorderedEXT = 5369, + ShadingRateInterlockOrderedEXT = 5370, + ShadingRateInterlockUnorderedEXT = 5371, + Max, + Invalid = ~0U, +}; + +enum class StorageClass : uint32_t +{ + UniformConstant = 0, + Input = 1, + Uniform = 2, + Output = 3, + Workgroup = 4, + CrossWorkgroup = 5, + Private = 6, + Function = 7, + Generic = 8, + PushConstant = 9, + AtomicCounter = 10, + Image = 11, + StorageBuffer = 12, + CallableDataNV = 5328, + IncomingCallableDataNV = 5329, + RayPayloadNV = 5338, + HitAttributeNV = 5339, + IncomingRayPayloadNV = 5342, + ShaderRecordBufferNV = 5343, + PhysicalStorageBufferEXT = 5349, + Max, + Invalid = ~0U, +}; + +enum class Dim : uint32_t +{ + _1D = 0, + _2D = 1, + _3D = 2, + Cube = 3, + Rect = 4, + Buffer = 5, + SubpassData = 6, + Max, + Invalid = ~0U, +}; + +enum class SamplerAddressingMode : uint32_t +{ + None = 0, + ClampToEdge = 1, + Clamp = 2, + Repeat = 3, + RepeatMirrored = 4, + Max, + Invalid = ~0U, +}; + +enum class SamplerFilterMode : uint32_t +{ + Nearest = 0, + Linear = 1, + Max, + Invalid = ~0U, +}; + +enum class ImageFormat : uint32_t +{ + Unknown = 0, + Rgba32f = 1, + Rgba16f = 2, + R32f = 3, + Rgba8 = 4, + Rgba8Snorm = 5, + Rg32f = 6, + Rg16f = 7, + R11fG11fB10f = 8, + R16f = 9, + Rgba16 = 10, + Rgb10A2 = 11, + Rg16 = 12, + Rg8 = 13, + R16 = 14, + R8 = 15, + Rgba16Snorm = 16, + Rg16Snorm = 17, + Rg8Snorm = 18, + R16Snorm = 19, + R8Snorm = 20, + Rgba32i = 21, + Rgba16i = 22, + Rgba8i = 23, + R32i = 24, + Rg32i = 25, + Rg16i = 26, + Rg8i = 27, + R16i = 28, + R8i = 29, + Rgba32ui = 30, + Rgba16ui = 31, + Rgba8ui = 32, + R32ui = 33, + Rgb10a2ui = 34, + Rg32ui = 35, + Rg16ui = 36, + Rg8ui = 37, + R16ui = 38, + R8ui = 39, + Max, + Invalid = ~0U, +}; + +enum class ImageChannelOrder : uint32_t +{ + R = 0, + A = 1, + RG = 2, + RA = 3, + RGB = 4, + RGBA = 5, + BGRA = 6, + ARGB = 7, + Intensity = 8, + Luminance = 9, + Rx = 10, + RGx = 11, + RGBx = 12, + Depth = 13, + DepthStencil = 14, + sRGB = 15, + sRGBx = 16, + sRGBA = 17, + sBGRA = 18, + ABGR = 19, + Max, + Invalid = ~0U, +}; + +enum class ImageChannelDataType : uint32_t +{ + SnormInt8 = 0, + SnormInt16 = 1, + UnormInt8 = 2, + UnormInt16 = 3, + UnormShort565 = 4, + UnormShort555 = 5, + UnormInt101010 = 6, + SignedInt8 = 7, + SignedInt16 = 8, + SignedInt32 = 9, + UnsignedInt8 = 10, + UnsignedInt16 = 11, + UnsignedInt32 = 12, + HalfFloat = 13, + Float = 14, + UnormInt24 = 15, + UnormInt101010_2 = 16, + Max, + Invalid = ~0U, +}; + +enum class FPRoundingMode : uint32_t +{ + RTE = 0, + RTZ = 1, + RTP = 2, + RTN = 3, + Max, + Invalid = ~0U, +}; + +enum class LinkageType : uint32_t +{ + Export = 0, + Import = 1, + Max, + Invalid = ~0U, +}; + +enum class AccessQualifier : uint32_t +{ + ReadOnly = 0, + WriteOnly = 1, + ReadWrite = 2, + Max, + Invalid = ~0U, +}; + +enum class FunctionParameterAttribute : uint32_t +{ + Zext = 0, + Sext = 1, + ByVal = 2, + Sret = 3, + NoAlias = 4, + NoCapture = 5, + NoWrite = 6, + NoReadWrite = 7, + Max, + Invalid = ~0U, +}; + +enum class Decoration : uint32_t +{ + RelaxedPrecision = 0, + SpecId = 1, + Block = 2, + BufferBlock = 3, + RowMajor = 4, + ColMajor = 5, + ArrayStride = 6, + MatrixStride = 7, + GLSLShared = 8, + GLSLPacked = 9, + CPacked = 10, + BuiltIn = 11, + NoPerspective = 13, + Flat = 14, + Patch = 15, + Centroid = 16, + Sample = 17, + Invariant = 18, + Restrict = 19, + Aliased = 20, + Volatile = 21, + Constant = 22, + Coherent = 23, + NonWritable = 24, + NonReadable = 25, + Uniform = 26, + UniformId = 27, + SaturatedConversion = 28, + Stream = 29, + Location = 30, + Component = 31, + Index = 32, + Binding = 33, + DescriptorSet = 34, + Offset = 35, + XfbBuffer = 36, + XfbStride = 37, + FuncParamAttr = 38, + FPRoundingMode = 39, + FPFastMathMode = 40, + LinkageAttributes = 41, + NoContraction = 42, + InputAttachmentIndex = 43, + Alignment = 44, + MaxByteOffset = 45, + AlignmentId = 46, + MaxByteOffsetId = 47, + NoSignedWrap = 4469, + NoUnsignedWrap = 4470, + ExplicitInterpAMD = 4999, + OverrideCoverageNV = 5248, + PassthroughNV = 5250, + ViewportRelativeNV = 5252, + SecondaryViewportRelativeNV = 5256, + PerPrimitiveNV = 5271, + PerViewNV = 5272, + PerTaskNV = 5273, + PerVertexNV = 5285, + NonUniformEXT = 5300, + RestrictPointerEXT = 5355, + AliasedPointerEXT = 5356, + CounterBuffer = 5634, + HlslCounterBufferGOOGLE = 5634, + UserSemantic = 5635, + HlslSemanticGOOGLE = 5635, + UserTypeGOOGLE = 5636, + Max, + Invalid = ~0U, +}; + +enum class BuiltIn : uint32_t +{ + Position = 0, + PointSize = 1, + ClipDistance = 3, + CullDistance = 4, + VertexId = 5, + InstanceId = 6, + PrimitiveId = 7, + InvocationId = 8, + Layer = 9, + ViewportIndex = 10, + TessLevelOuter = 11, + TessLevelInner = 12, + TessCoord = 13, + PatchVertices = 14, + FragCoord = 15, + PointCoord = 16, + FrontFacing = 17, + SampleId = 18, + SamplePosition = 19, + SampleMask = 20, + FragDepth = 22, + HelperInvocation = 23, + NumWorkgroups = 24, + WorkgroupSize = 25, + WorkgroupId = 26, + LocalInvocationId = 27, + GlobalInvocationId = 28, + LocalInvocationIndex = 29, + WorkDim = 30, + GlobalSize = 31, + EnqueuedWorkgroupSize = 32, + GlobalOffset = 33, + GlobalLinearId = 34, + SubgroupSize = 36, + SubgroupMaxSize = 37, + NumSubgroups = 38, + NumEnqueuedSubgroups = 39, + SubgroupId = 40, + SubgroupLocalInvocationId = 41, + VertexIndex = 42, + InstanceIndex = 43, + SubgroupEqMask = 4416, + SubgroupGeMask = 4417, + SubgroupGtMask = 4418, + SubgroupLeMask = 4419, + SubgroupLtMask = 4420, + SubgroupEqMaskKHR = 4416, + SubgroupGeMaskKHR = 4417, + SubgroupGtMaskKHR = 4418, + SubgroupLeMaskKHR = 4419, + SubgroupLtMaskKHR = 4420, + BaseVertex = 4424, + BaseInstance = 4425, + DrawIndex = 4426, + DeviceIndex = 4438, + ViewIndex = 4440, + BaryCoordNoPerspAMD = 4992, + BaryCoordNoPerspCentroidAMD = 4993, + BaryCoordNoPerspSampleAMD = 4994, + BaryCoordSmoothAMD = 4995, + BaryCoordSmoothCentroidAMD = 4996, + BaryCoordSmoothSampleAMD = 4997, + BaryCoordPullModelAMD = 4998, + FragStencilRefEXT = 5014, + ViewportMaskNV = 5253, + SecondaryPositionNV = 5257, + SecondaryViewportMaskNV = 5258, + PositionPerViewNV = 5261, + ViewportMaskPerViewNV = 5262, + FullyCoveredEXT = 5264, + TaskCountNV = 5274, + PrimitiveCountNV = 5275, + PrimitiveIndicesNV = 5276, + ClipDistancePerViewNV = 5277, + CullDistancePerViewNV = 5278, + LayerPerViewNV = 5279, + MeshViewCountNV = 5280, + MeshViewIndicesNV = 5281, + BaryCoordNV = 5286, + BaryCoordNoPerspNV = 5287, + FragSizeEXT = 5292, + FragmentSizeNV = 5292, + FragInvocationCountEXT = 5293, + InvocationsPerPixelNV = 5293, + LaunchIdNV = 5319, + LaunchSizeNV = 5320, + WorldRayOriginNV = 5321, + WorldRayDirectionNV = 5322, + ObjectRayOriginNV = 5323, + ObjectRayDirectionNV = 5324, + RayTminNV = 5325, + RayTmaxNV = 5326, + InstanceCustomIndexNV = 5327, + ObjectToWorldNV = 5330, + WorldToObjectNV = 5331, + HitTNV = 5332, + HitKindNV = 5333, + IncomingRayFlagsNV = 5351, + WarpsPerSMNV = 5374, + SMCountNV = 5375, + WarpIDNV = 5376, + SMIDNV = 5377, + Max, + Invalid = ~0U, +}; + +enum class Scope : uint32_t +{ + CrossDevice = 0, + Device = 1, + Workgroup = 2, + Subgroup = 3, + Invocation = 4, + QueueFamilyKHR = 5, + Max, + Invalid = ~0U, +}; + +enum class GroupOperation : uint32_t +{ + Reduce = 0, + InclusiveScan = 1, + ExclusiveScan = 2, + ClusteredReduce = 3, + PartitionedReduceNV = 6, + PartitionedInclusiveScanNV = 7, + PartitionedExclusiveScanNV = 8, + Max, + Invalid = ~0U, +}; + +enum class KernelEnqueueFlags : uint32_t +{ + NoWait = 0, + WaitKernel = 1, + WaitWorkGroup = 2, + Max, + Invalid = ~0U, +}; + +enum class Capability : uint32_t +{ + Matrix = 0, + Shader = 1, + Geometry = 2, + Tessellation = 3, + Addresses = 4, + Linkage = 5, + Kernel = 6, + Vector16 = 7, + Float16Buffer = 8, + Float16 = 9, + Float64 = 10, + Int64 = 11, + Int64Atomics = 12, + ImageBasic = 13, + ImageReadWrite = 14, + ImageMipmap = 15, + Pipes = 17, + Groups = 18, + DeviceEnqueue = 19, + LiteralSampler = 20, + AtomicStorage = 21, + Int16 = 22, + TessellationPointSize = 23, + GeometryPointSize = 24, + ImageGatherExtended = 25, + StorageImageMultisample = 27, + UniformBufferArrayDynamicIndexing = 28, + SampledImageArrayDynamicIndexing = 29, + StorageBufferArrayDynamicIndexing = 30, + StorageImageArrayDynamicIndexing = 31, + ClipDistance = 32, + CullDistance = 33, + ImageCubeArray = 34, + SampleRateShading = 35, + ImageRect = 36, + SampledRect = 37, + GenericPointer = 38, + Int8 = 39, + InputAttachment = 40, + SparseResidency = 41, + MinLod = 42, + Sampled1D = 43, + Image1D = 44, + SampledCubeArray = 45, + SampledBuffer = 46, + ImageBuffer = 47, + ImageMSArray = 48, + StorageImageExtendedFormats = 49, + ImageQuery = 50, + DerivativeControl = 51, + InterpolationFunction = 52, + TransformFeedback = 53, + GeometryStreams = 54, + StorageImageReadWithoutFormat = 55, + StorageImageWriteWithoutFormat = 56, + MultiViewport = 57, + SubgroupDispatch = 58, + NamedBarrier = 59, + PipeStorage = 60, + GroupNonUniform = 61, + GroupNonUniformVote = 62, + GroupNonUniformArithmetic = 63, + GroupNonUniformBallot = 64, + GroupNonUniformShuffle = 65, + GroupNonUniformShuffleRelative = 66, + GroupNonUniformClustered = 67, + GroupNonUniformQuad = 68, + SubgroupBallotKHR = 4423, + DrawParameters = 4427, + SubgroupVoteKHR = 4431, + StorageBuffer16BitAccess = 4433, + StorageUniformBufferBlock16 = 4433, + UniformAndStorageBuffer16BitAccess = 4434, + StorageUniform16 = 4434, + StoragePushConstant16 = 4435, + StorageInputOutput16 = 4436, + DeviceGroup = 4437, + MultiView = 4439, + VariablePointersStorageBuffer = 4441, + VariablePointers = 4442, + AtomicStorageOps = 4445, + SampleMaskPostDepthCoverage = 4447, + StorageBuffer8BitAccess = 4448, + UniformAndStorageBuffer8BitAccess = 4449, + StoragePushConstant8 = 4450, + DenormPreserve = 4464, + DenormFlushToZero = 4465, + SignedZeroInfNanPreserve = 4466, + RoundingModeRTE = 4467, + RoundingModeRTZ = 4468, + Float16ImageAMD = 5008, + ImageGatherBiasLodAMD = 5009, + FragmentMaskAMD = 5010, + StencilExportEXT = 5013, + ImageReadWriteLodAMD = 5015, + ShaderClockKHR = 5055, + SampleMaskOverrideCoverageNV = 5249, + GeometryShaderPassthroughNV = 5251, + ShaderViewportIndexLayerEXT = 5254, + ShaderViewportIndexLayerNV = 5254, + ShaderViewportMaskNV = 5255, + ShaderStereoViewNV = 5259, + PerViewAttributesNV = 5260, + FragmentFullyCoveredEXT = 5265, + MeshShadingNV = 5266, + ImageFootprintNV = 5282, + FragmentBarycentricNV = 5284, + ComputeDerivativeGroupQuadsNV = 5288, + FragmentDensityEXT = 5291, + ShadingRateNV = 5291, + GroupNonUniformPartitionedNV = 5297, + ShaderNonUniformEXT = 5301, + RuntimeDescriptorArrayEXT = 5302, + InputAttachmentArrayDynamicIndexingEXT = 5303, + UniformTexelBufferArrayDynamicIndexingEXT = 5304, + StorageTexelBufferArrayDynamicIndexingEXT = 5305, + UniformBufferArrayNonUniformIndexingEXT = 5306, + SampledImageArrayNonUniformIndexingEXT = 5307, + StorageBufferArrayNonUniformIndexingEXT = 5308, + StorageImageArrayNonUniformIndexingEXT = 5309, + InputAttachmentArrayNonUniformIndexingEXT = 5310, + UniformTexelBufferArrayNonUniformIndexingEXT = 5311, + StorageTexelBufferArrayNonUniformIndexingEXT = 5312, + RayTracingNV = 5340, + VulkanMemoryModelKHR = 5345, + VulkanMemoryModelDeviceScopeKHR = 5346, + PhysicalStorageBufferAddressesEXT = 5347, + ComputeDerivativeGroupLinearNV = 5350, + CooperativeMatrixNV = 5357, + FragmentShaderSampleInterlockEXT = 5363, + FragmentShaderShadingRateInterlockEXT = 5372, + ShaderSMBuiltinsNV = 5373, + FragmentShaderPixelInterlockEXT = 5378, + DemoteToHelperInvocationEXT = 5379, + SubgroupShuffleINTEL = 5568, + SubgroupBufferBlockIOINTEL = 5569, + SubgroupImageBlockIOINTEL = 5570, + SubgroupImageMediaBlockIOINTEL = 5579, + IntegerFunctions2INTEL = 5584, + SubgroupAvcMotionEstimationINTEL = 5696, + SubgroupAvcMotionEstimationIntraINTEL = 5697, + SubgroupAvcMotionEstimationChromaINTEL = 5698, + Max, + Invalid = ~0U, +}; + +using IdResultType = Id; + +using IdResult = Id; + +using IdMemorySemantics = Id; + +using IdScope = Id; + +struct GradParams +{ + Id first; + Id second; +}; + +struct ImageOperandsAndParamDatas +{ + ImageOperandsAndParamDatas(ImageOperands f = ImageOperands::None) : flags(f) {} + ImageOperands flags; + Id bias; + Id lod; + GradParams grad; + Id constOffset; + Id offset; + Id constOffsets; + Id sample; + Id minLod; + IdScope makeTexelAvailableKHR; + IdScope makeTexelVisibleKHR; + + operator ImageOperands() const { return flags; } + bool operator &(const ImageOperands v) const { return bool(flags & v); } + void setNone() { flags |= ImageOperands::None; } + void unsetNone() { flags &= ~ImageOperands::None; } + void setBias(Id biasParam) { flags |= ImageOperands::Bias; bias = biasParam; } + void unsetBias() { flags &= ~ImageOperands::Bias; } + void setLod(Id lodParam) { flags |= ImageOperands::Lod; lod = lodParam; } + void unsetLod() { flags &= ~ImageOperands::Lod; } + void setGrad(Id first, Id second) { flags |= ImageOperands::Grad; grad.first = first; grad.second = second; } + void unsetGrad() { flags &= ~ImageOperands::Grad; } + void setConstOffset(Id constOffsetParam) { flags |= ImageOperands::ConstOffset; constOffset = constOffsetParam; } + void unsetConstOffset() { flags &= ~ImageOperands::ConstOffset; } + void setOffset(Id offsetParam) { flags |= ImageOperands::Offset; offset = offsetParam; } + void unsetOffset() { flags &= ~ImageOperands::Offset; } + void setConstOffsets(Id constOffsetsParam) { flags |= ImageOperands::ConstOffsets; constOffsets = constOffsetsParam; } + void unsetConstOffsets() { flags &= ~ImageOperands::ConstOffsets; } + void setSample(Id sampleParam) { flags |= ImageOperands::Sample; sample = sampleParam; } + void unsetSample() { flags &= ~ImageOperands::Sample; } + void setMinLod(Id minLodParam) { flags |= ImageOperands::MinLod; minLod = minLodParam; } + void unsetMinLod() { flags &= ~ImageOperands::MinLod; } + void setMakeTexelAvailableKHR(IdScope makeTexelAvailableKHRParam) { flags |= ImageOperands::MakeTexelAvailableKHR; makeTexelAvailableKHR = makeTexelAvailableKHRParam; } + void unsetMakeTexelAvailableKHR() { flags &= ~ImageOperands::MakeTexelAvailableKHR; } + void setMakeTexelVisibleKHR(IdScope makeTexelVisibleKHRParam) { flags |= ImageOperands::MakeTexelVisibleKHR; makeTexelVisibleKHR = makeTexelVisibleKHRParam; } + void unsetMakeTexelVisibleKHR() { flags &= ~ImageOperands::MakeTexelVisibleKHR; } + void setNonPrivateTexelKHR() { flags |= ImageOperands::NonPrivateTexelKHR; } + void unsetNonPrivateTexelKHR() { flags &= ~ImageOperands::NonPrivateTexelKHR; } + void setVolatileTexelKHR() { flags |= ImageOperands::VolatileTexelKHR; } + void unsetVolatileTexelKHR() { flags &= ~ImageOperands::VolatileTexelKHR; } + void setSignExtend() { flags |= ImageOperands::SignExtend; } + void unsetSignExtend() { flags &= ~ImageOperands::SignExtend; } + void setZeroExtend() { flags |= ImageOperands::ZeroExtend; } + void unsetZeroExtend() { flags &= ~ImageOperands::ZeroExtend; } +}; + +struct LoopControlAndParamDatas +{ + LoopControlAndParamDatas(LoopControl f = LoopControl::None) : flags(f) {} + LoopControl flags; + uint32_t dependencyLength; + uint32_t minIterations; + uint32_t maxIterations; + uint32_t iterationMultiple; + uint32_t peelCount; + uint32_t partialCount; + + operator LoopControl() const { return flags; } + bool operator &(const LoopControl v) const { return bool(flags & v); } + void setNone() { flags |= LoopControl::None; } + void unsetNone() { flags &= ~LoopControl::None; } + void setUnroll() { flags |= LoopControl::Unroll; } + void unsetUnroll() { flags &= ~LoopControl::Unroll; } + void setDontUnroll() { flags |= LoopControl::DontUnroll; } + void unsetDontUnroll() { flags &= ~LoopControl::DontUnroll; } + void setDependencyInfinite() { flags |= LoopControl::DependencyInfinite; } + void unsetDependencyInfinite() { flags &= ~LoopControl::DependencyInfinite; } + void setDependencyLength(uint32_t dependencyLengthParam) { flags |= LoopControl::DependencyLength; dependencyLength = dependencyLengthParam; } + void unsetDependencyLength() { flags &= ~LoopControl::DependencyLength; } + void setMinIterations(uint32_t minIterationsParam) { flags |= LoopControl::MinIterations; minIterations = minIterationsParam; } + void unsetMinIterations() { flags &= ~LoopControl::MinIterations; } + void setMaxIterations(uint32_t maxIterationsParam) { flags |= LoopControl::MaxIterations; maxIterations = maxIterationsParam; } + void unsetMaxIterations() { flags &= ~LoopControl::MaxIterations; } + void setIterationMultiple(uint32_t iterationMultipleParam) { flags |= LoopControl::IterationMultiple; iterationMultiple = iterationMultipleParam; } + void unsetIterationMultiple() { flags &= ~LoopControl::IterationMultiple; } + void setPeelCount(uint32_t peelCountParam) { flags |= LoopControl::PeelCount; peelCount = peelCountParam; } + void unsetPeelCount() { flags &= ~LoopControl::PeelCount; } + void setPartialCount(uint32_t partialCountParam) { flags |= LoopControl::PartialCount; partialCount = partialCountParam; } + void unsetPartialCount() { flags &= ~LoopControl::PartialCount; } +}; + +struct MemoryAccessAndParamDatas +{ + MemoryAccessAndParamDatas(MemoryAccess f = MemoryAccess::None) : flags(f) {} + MemoryAccess flags; + uint32_t aligned; + IdScope makePointerAvailableKHR; + IdScope makePointerVisibleKHR; + + operator MemoryAccess() const { return flags; } + bool operator &(const MemoryAccess v) const { return bool(flags & v); } + void setNone() { flags |= MemoryAccess::None; } + void unsetNone() { flags &= ~MemoryAccess::None; } + void setVolatile() { flags |= MemoryAccess::Volatile; } + void unsetVolatile() { flags &= ~MemoryAccess::Volatile; } + void setAligned(uint32_t alignedParam) { flags |= MemoryAccess::Aligned; aligned = alignedParam; } + void unsetAligned() { flags &= ~MemoryAccess::Aligned; } + void setNontemporal() { flags |= MemoryAccess::Nontemporal; } + void unsetNontemporal() { flags &= ~MemoryAccess::Nontemporal; } + void setMakePointerAvailableKHR(IdScope makePointerAvailableKHRParam) { flags |= MemoryAccess::MakePointerAvailableKHR; makePointerAvailableKHR = makePointerAvailableKHRParam; } + void unsetMakePointerAvailableKHR() { flags &= ~MemoryAccess::MakePointerAvailableKHR; } + void setMakePointerVisibleKHR(IdScope makePointerVisibleKHRParam) { flags |= MemoryAccess::MakePointerVisibleKHR; makePointerVisibleKHR = makePointerVisibleKHRParam; } + void unsetMakePointerVisibleKHR() { flags &= ~MemoryAccess::MakePointerVisibleKHR; } + void setNonPrivatePointerKHR() { flags |= MemoryAccess::NonPrivatePointerKHR; } + void unsetNonPrivatePointerKHR() { flags &= ~MemoryAccess::NonPrivatePointerKHR; } +}; + +struct LocalSizeParams +{ + uint32_t xsize; + uint32_t ysize; + uint32_t zsize; +}; + +struct LocalSizeHintParams +{ + uint32_t xsize; + uint32_t ysize; + uint32_t zsize; +}; + +struct LocalSizeIdParams +{ + Id xsize; + Id ysize; + Id zsize; +}; + +struct ExecutionModeAndParamData +{ + ExecutionModeAndParamData(ExecutionMode v = ExecutionMode::Invalid) : value(v) {} + ExecutionMode value; + union + { + uint32_t invocations; + LocalSizeParams localSize; + LocalSizeHintParams localSizeHint; + uint32_t outputVertices; + uint32_t vecTypeHint; + uint32_t subgroupSize; + uint32_t subgroupsPerWorkgroup; + Id subgroupsPerWorkgroupId; + LocalSizeIdParams localSizeId; + Id localSizeHintId; + uint32_t denormPreserve; + uint32_t denormFlushToZero; + uint32_t signedZeroInfNanPreserve; + uint32_t roundingModeRTE; + uint32_t roundingModeRTZ; + uint32_t outputPrimitivesNV; + }; + + operator ExecutionMode() const { return value; } + bool operator ==(const ExecutionMode v) const { return value == v; } +}; + +struct DecorationAndParamData +{ + DecorationAndParamData(Decoration v = Decoration::Invalid) : value(v) {} + Decoration value; + union + { + uint32_t specId; + uint32_t arrayStride; + uint32_t matrixStride; + BuiltIn builtIn; + IdScope uniformId; + uint32_t stream; + uint32_t location; + uint32_t component; + uint32_t index; + uint32_t binding; + uint32_t descriptorSet; + uint32_t offset; + uint32_t xfbBuffer; + uint32_t xfbStride; + FunctionParameterAttribute funcParamAttr; + FPRoundingMode fPRoundingMode; + FPFastMathMode fPFastMathMode; + uint32_t inputAttachmentIndex; + uint32_t alignment; + uint32_t maxByteOffset; + Id alignmentId; + Id maxByteOffsetId; + uint32_t secondaryViewportRelativeNV; + Id counterBuffer; + Id hlslCounterBufferGOOGLE; + }; + + operator Decoration() const { return value; } + bool operator ==(const Decoration v) const { return value == v; } +}; + +enum class Op : uint16_t +{ + Nop = 0, + Undef = 1, + SourceContinued = 2, + Source = 3, + SourceExtension = 4, + Name = 5, + MemberName = 6, + String = 7, + Line = 8, + Extension = 10, + ExtInstImport = 11, + ExtInst = 12, + MemoryModel = 14, + EntryPoint = 15, + ExecutionMode = 16, + Capability = 17, + TypeVoid = 19, + TypeBool = 20, + TypeInt = 21, + TypeFloat = 22, + TypeVector = 23, + TypeMatrix = 24, + TypeImage = 25, + TypeSampler = 26, + TypeSampledImage = 27, + TypeArray = 28, + TypeRuntimeArray = 29, + TypeStruct = 30, + TypeOpaque = 31, + TypePointer = 32, + TypeFunction = 33, + TypeEvent = 34, + TypeDeviceEvent = 35, + TypeReserveId = 36, + TypeQueue = 37, + TypePipe = 38, + TypeForwardPointer = 39, + ConstantTrue = 41, + ConstantFalse = 42, + Constant = 43, + ConstantComposite = 44, + ConstantSampler = 45, + ConstantNull = 46, + SpecConstantTrue = 48, + SpecConstantFalse = 49, + SpecConstant = 50, + SpecConstantComposite = 51, + SpecConstantOp = 52, + Function = 54, + FunctionParameter = 55, + FunctionEnd = 56, + FunctionCall = 57, + Variable = 59, + ImageTexelPointer = 60, + Load = 61, + Store = 62, + CopyMemory = 63, + CopyMemorySized = 64, + AccessChain = 65, + InBoundsAccessChain = 66, + PtrAccessChain = 67, + ArrayLength = 68, + GenericPtrMemSemantics = 69, + InBoundsPtrAccessChain = 70, + Decorate = 71, + MemberDecorate = 72, + DecorationGroup = 73, + GroupDecorate = 74, + GroupMemberDecorate = 75, + VectorExtractDynamic = 77, + VectorInsertDynamic = 78, + VectorShuffle = 79, + CompositeConstruct = 80, + CompositeExtract = 81, + CompositeInsert = 82, + CopyObject = 83, + Transpose = 84, + SampledImage = 86, + ImageSampleImplicitLod = 87, + ImageSampleExplicitLod = 88, + ImageSampleDrefImplicitLod = 89, + ImageSampleDrefExplicitLod = 90, + ImageSampleProjImplicitLod = 91, + ImageSampleProjExplicitLod = 92, + ImageSampleProjDrefImplicitLod = 93, + ImageSampleProjDrefExplicitLod = 94, + ImageFetch = 95, + ImageGather = 96, + ImageDrefGather = 97, + ImageRead = 98, + ImageWrite = 99, + Image = 100, + ImageQueryFormat = 101, + ImageQueryOrder = 102, + ImageQuerySizeLod = 103, + ImageQuerySize = 104, + ImageQueryLod = 105, + ImageQueryLevels = 106, + ImageQuerySamples = 107, + ConvertFToU = 109, + ConvertFToS = 110, + ConvertSToF = 111, + ConvertUToF = 112, + UConvert = 113, + SConvert = 114, + FConvert = 115, + QuantizeToF16 = 116, + ConvertPtrToU = 117, + SatConvertSToU = 118, + SatConvertUToS = 119, + ConvertUToPtr = 120, + PtrCastToGeneric = 121, + GenericCastToPtr = 122, + GenericCastToPtrExplicit = 123, + Bitcast = 124, + SNegate = 126, + FNegate = 127, + IAdd = 128, + FAdd = 129, + ISub = 130, + FSub = 131, + IMul = 132, + FMul = 133, + UDiv = 134, + SDiv = 135, + FDiv = 136, + UMod = 137, + SRem = 138, + SMod = 139, + FRem = 140, + FMod = 141, + VectorTimesScalar = 142, + MatrixTimesScalar = 143, + VectorTimesMatrix = 144, + MatrixTimesVector = 145, + MatrixTimesMatrix = 146, + OuterProduct = 147, + Dot = 148, + IAddCarry = 149, + ISubBorrow = 150, + UMulExtended = 151, + SMulExtended = 152, + Any = 154, + All = 155, + IsNan = 156, + IsInf = 157, + IsFinite = 158, + IsNormal = 159, + SignBitSet = 160, + LessOrGreater = 161, + Ordered = 162, + Unordered = 163, + LogicalEqual = 164, + LogicalNotEqual = 165, + LogicalOr = 166, + LogicalAnd = 167, + LogicalNot = 168, + Select = 169, + IEqual = 170, + INotEqual = 171, + UGreaterThan = 172, + SGreaterThan = 173, + UGreaterThanEqual = 174, + SGreaterThanEqual = 175, + ULessThan = 176, + SLessThan = 177, + ULessThanEqual = 178, + SLessThanEqual = 179, + FOrdEqual = 180, + FUnordEqual = 181, + FOrdNotEqual = 182, + FUnordNotEqual = 183, + FOrdLessThan = 184, + FUnordLessThan = 185, + FOrdGreaterThan = 186, + FUnordGreaterThan = 187, + FOrdLessThanEqual = 188, + FUnordLessThanEqual = 189, + FOrdGreaterThanEqual = 190, + FUnordGreaterThanEqual = 191, + ShiftRightLogical = 194, + ShiftRightArithmetic = 195, + ShiftLeftLogical = 196, + BitwiseOr = 197, + BitwiseXor = 198, + BitwiseAnd = 199, + Not = 200, + BitFieldInsert = 201, + BitFieldSExtract = 202, + BitFieldUExtract = 203, + BitReverse = 204, + BitCount = 205, + DPdx = 207, + DPdy = 208, + Fwidth = 209, + DPdxFine = 210, + DPdyFine = 211, + FwidthFine = 212, + DPdxCoarse = 213, + DPdyCoarse = 214, + FwidthCoarse = 215, + EmitVertex = 218, + EndPrimitive = 219, + EmitStreamVertex = 220, + EndStreamPrimitive = 221, + ControlBarrier = 224, + MemoryBarrier = 225, + AtomicLoad = 227, + AtomicStore = 228, + AtomicExchange = 229, + AtomicCompareExchange = 230, + AtomicCompareExchangeWeak = 231, + AtomicIIncrement = 232, + AtomicIDecrement = 233, + AtomicIAdd = 234, + AtomicISub = 235, + AtomicSMin = 236, + AtomicUMin = 237, + AtomicSMax = 238, + AtomicUMax = 239, + AtomicAnd = 240, + AtomicOr = 241, + AtomicXor = 242, + Phi = 245, + LoopMerge = 246, + SelectionMerge = 247, + Label = 248, + Branch = 249, + BranchConditional = 250, + Switch = 251, + Kill = 252, + Return = 253, + ReturnValue = 254, + Unreachable = 255, + LifetimeStart = 256, + LifetimeStop = 257, + GroupAsyncCopy = 259, + GroupWaitEvents = 260, + GroupAll = 261, + GroupAny = 262, + GroupBroadcast = 263, + GroupIAdd = 264, + GroupFAdd = 265, + GroupFMin = 266, + GroupUMin = 267, + GroupSMin = 268, + GroupFMax = 269, + GroupUMax = 270, + GroupSMax = 271, + ReadPipe = 274, + WritePipe = 275, + ReservedReadPipe = 276, + ReservedWritePipe = 277, + ReserveReadPipePackets = 278, + ReserveWritePipePackets = 279, + CommitReadPipe = 280, + CommitWritePipe = 281, + IsValidReserveId = 282, + GetNumPipePackets = 283, + GetMaxPipePackets = 284, + GroupReserveReadPipePackets = 285, + GroupReserveWritePipePackets = 286, + GroupCommitReadPipe = 287, + GroupCommitWritePipe = 288, + EnqueueMarker = 291, + EnqueueKernel = 292, + GetKernelNDrangeSubGroupCount = 293, + GetKernelNDrangeMaxSubGroupSize = 294, + GetKernelWorkGroupSize = 295, + GetKernelPreferredWorkGroupSizeMultiple = 296, + RetainEvent = 297, + ReleaseEvent = 298, + CreateUserEvent = 299, + IsValidEvent = 300, + SetUserEventStatus = 301, + CaptureEventProfilingInfo = 302, + GetDefaultQueue = 303, + BuildNDRange = 304, + ImageSparseSampleImplicitLod = 305, + ImageSparseSampleExplicitLod = 306, + ImageSparseSampleDrefImplicitLod = 307, + ImageSparseSampleDrefExplicitLod = 308, + ImageSparseSampleProjImplicitLod = 309, + ImageSparseSampleProjExplicitLod = 310, + ImageSparseSampleProjDrefImplicitLod = 311, + ImageSparseSampleProjDrefExplicitLod = 312, + ImageSparseFetch = 313, + ImageSparseGather = 314, + ImageSparseDrefGather = 315, + ImageSparseTexelsResident = 316, + NoLine = 317, + AtomicFlagTestAndSet = 318, + AtomicFlagClear = 319, + ImageSparseRead = 320, + SizeOf = 321, + TypePipeStorage = 322, + ConstantPipeStorage = 323, + CreatePipeFromPipeStorage = 324, + GetKernelLocalSizeForSubgroupCount = 325, + GetKernelMaxNumSubgroups = 326, + TypeNamedBarrier = 327, + NamedBarrierInitialize = 328, + MemoryNamedBarrier = 329, + ModuleProcessed = 330, + ExecutionModeId = 331, + DecorateId = 332, + GroupNonUniformElect = 333, + GroupNonUniformAll = 334, + GroupNonUniformAny = 335, + GroupNonUniformAllEqual = 336, + GroupNonUniformBroadcast = 337, + GroupNonUniformBroadcastFirst = 338, + GroupNonUniformBallot = 339, + GroupNonUniformInverseBallot = 340, + GroupNonUniformBallotBitExtract = 341, + GroupNonUniformBallotBitCount = 342, + GroupNonUniformBallotFindLSB = 343, + GroupNonUniformBallotFindMSB = 344, + GroupNonUniformShuffle = 345, + GroupNonUniformShuffleXor = 346, + GroupNonUniformShuffleUp = 347, + GroupNonUniformShuffleDown = 348, + GroupNonUniformIAdd = 349, + GroupNonUniformFAdd = 350, + GroupNonUniformIMul = 351, + GroupNonUniformFMul = 352, + GroupNonUniformSMin = 353, + GroupNonUniformUMin = 354, + GroupNonUniformFMin = 355, + GroupNonUniformSMax = 356, + GroupNonUniformUMax = 357, + GroupNonUniformFMax = 358, + GroupNonUniformBitwiseAnd = 359, + GroupNonUniformBitwiseOr = 360, + GroupNonUniformBitwiseXor = 361, + GroupNonUniformLogicalAnd = 362, + GroupNonUniformLogicalOr = 363, + GroupNonUniformLogicalXor = 364, + GroupNonUniformQuadBroadcast = 365, + GroupNonUniformQuadSwap = 366, + CopyLogical = 400, + PtrEqual = 401, + PtrNotEqual = 402, + PtrDiff = 403, + SubgroupBallotKHR = 4421, + SubgroupFirstInvocationKHR = 4422, + SubgroupAllKHR = 4428, + SubgroupAnyKHR = 4429, + SubgroupAllEqualKHR = 4430, + SubgroupReadInvocationKHR = 4432, + GroupIAddNonUniformAMD = 5000, + GroupFAddNonUniformAMD = 5001, + GroupFMinNonUniformAMD = 5002, + GroupUMinNonUniformAMD = 5003, + GroupSMinNonUniformAMD = 5004, + GroupFMaxNonUniformAMD = 5005, + GroupUMaxNonUniformAMD = 5006, + GroupSMaxNonUniformAMD = 5007, + FragmentMaskFetchAMD = 5011, + FragmentFetchAMD = 5012, + ReadClockKHR = 5056, + ImageSampleFootprintNV = 5283, + GroupNonUniformPartitionNV = 5296, + WritePackedPrimitiveIndices4x8NV = 5299, + ReportIntersectionNV = 5334, + IgnoreIntersectionNV = 5335, + TerminateRayNV = 5336, + TraceNV = 5337, + TypeAccelerationStructureNV = 5341, + ExecuteCallableNV = 5344, + TypeCooperativeMatrixNV = 5358, + CooperativeMatrixLoadNV = 5359, + CooperativeMatrixStoreNV = 5360, + CooperativeMatrixMulAddNV = 5361, + CooperativeMatrixLengthNV = 5362, + BeginInvocationInterlockEXT = 5364, + EndInvocationInterlockEXT = 5365, + DemoteToHelperInvocationEXT = 5380, + IsHelperInvocationEXT = 5381, + SubgroupShuffleINTEL = 5571, + SubgroupShuffleDownINTEL = 5572, + SubgroupShuffleUpINTEL = 5573, + SubgroupShuffleXorINTEL = 5574, + SubgroupBlockReadINTEL = 5575, + SubgroupBlockWriteINTEL = 5576, + SubgroupImageBlockReadINTEL = 5577, + SubgroupImageBlockWriteINTEL = 5578, + SubgroupImageMediaBlockReadINTEL = 5580, + SubgroupImageMediaBlockWriteINTEL = 5581, + UCountLeadingZerosINTEL = 5585, + UCountTrailingZerosINTEL = 5586, + AbsISubINTEL = 5587, + AbsUSubINTEL = 5588, + IAddSatINTEL = 5589, + UAddSatINTEL = 5590, + IAverageINTEL = 5591, + UAverageINTEL = 5592, + IAverageRoundedINTEL = 5593, + UAverageRoundedINTEL = 5594, + ISubSatINTEL = 5595, + USubSatINTEL = 5596, + IMul32x16INTEL = 5597, + UMul32x16INTEL = 5598, + DecorateString = 5632, + DecorateStringGOOGLE = 5632, + MemberDecorateString = 5633, + MemberDecorateStringGOOGLE = 5633, + VmeImageINTEL = 5699, + TypeVmeImageINTEL = 5700, + TypeAvcImePayloadINTEL = 5701, + TypeAvcRefPayloadINTEL = 5702, + TypeAvcSicPayloadINTEL = 5703, + TypeAvcMcePayloadINTEL = 5704, + TypeAvcMceResultINTEL = 5705, + TypeAvcImeResultINTEL = 5706, + TypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, + TypeAvcImeResultDualReferenceStreamoutINTEL = 5708, + TypeAvcImeSingleReferenceStreaminINTEL = 5709, + TypeAvcImeDualReferenceStreaminINTEL = 5710, + TypeAvcRefResultINTEL = 5711, + TypeAvcSicResultINTEL = 5712, + SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, + SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, + SubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, + SubgroupAvcMceSetInterShapePenaltyINTEL = 5716, + SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, + SubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, + SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, + SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, + SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, + SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, + SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, + SubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, + SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, + SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, + SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, + SubgroupAvcMceSetAcOnlyHaarINTEL = 5728, + SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, + SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, + SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, + SubgroupAvcMceConvertToImePayloadINTEL = 5732, + SubgroupAvcMceConvertToImeResultINTEL = 5733, + SubgroupAvcMceConvertToRefPayloadINTEL = 5734, + SubgroupAvcMceConvertToRefResultINTEL = 5735, + SubgroupAvcMceConvertToSicPayloadINTEL = 5736, + SubgroupAvcMceConvertToSicResultINTEL = 5737, + SubgroupAvcMceGetMotionVectorsINTEL = 5738, + SubgroupAvcMceGetInterDistortionsINTEL = 5739, + SubgroupAvcMceGetBestInterDistortionsINTEL = 5740, + SubgroupAvcMceGetInterMajorShapeINTEL = 5741, + SubgroupAvcMceGetInterMinorShapeINTEL = 5742, + SubgroupAvcMceGetInterDirectionsINTEL = 5743, + SubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, + SubgroupAvcMceGetInterReferenceIdsINTEL = 5745, + SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, + SubgroupAvcImeInitializeINTEL = 5747, + SubgroupAvcImeSetSingleReferenceINTEL = 5748, + SubgroupAvcImeSetDualReferenceINTEL = 5749, + SubgroupAvcImeRefWindowSizeINTEL = 5750, + SubgroupAvcImeAdjustRefOffsetINTEL = 5751, + SubgroupAvcImeConvertToMcePayloadINTEL = 5752, + SubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, + SubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, + SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, + SubgroupAvcImeSetWeightedSadINTEL = 5756, + SubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, + SubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, + SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, + SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, + SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, + SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, + SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, + SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, + SubgroupAvcImeConvertToMceResultINTEL = 5765, + SubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, + SubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, + SubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, + SubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, + SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, + SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, + SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, + SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, + SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, + SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, + SubgroupAvcImeGetBorderReachedINTEL = 5776, + SubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, + SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, + SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, + SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, + SubgroupAvcFmeInitializeINTEL = 5781, + SubgroupAvcBmeInitializeINTEL = 5782, + SubgroupAvcRefConvertToMcePayloadINTEL = 5783, + SubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, + SubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, + SubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, + SubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, + SubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, + SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, + SubgroupAvcRefConvertToMceResultINTEL = 5790, + SubgroupAvcSicInitializeINTEL = 5791, + SubgroupAvcSicConfigureSkcINTEL = 5792, + SubgroupAvcSicConfigureIpeLumaINTEL = 5793, + SubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, + SubgroupAvcSicGetMotionVectorMaskINTEL = 5795, + SubgroupAvcSicConvertToMcePayloadINTEL = 5796, + SubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, + SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, + SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, + SubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, + SubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, + SubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, + SubgroupAvcSicEvaluateIpeINTEL = 5803, + SubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, + SubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, + SubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, + SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, + SubgroupAvcSicConvertToMceResultINTEL = 5808, + SubgroupAvcSicGetIpeLumaShapeINTEL = 5809, + SubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, + SubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, + SubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, + SubgroupAvcSicGetIpeChromaModeINTEL = 5813, + SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, + SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, + SubgroupAvcSicGetInterRawSadsINTEL = 5816, + + Max, +}; + +enum class GLSLstd450 : uint32_t +{ + Round = 1, + RoundEven = 2, + Trunc = 3, + FAbs = 4, + SAbs = 5, + FSign = 6, + SSign = 7, + Floor = 8, + Ceil = 9, + Fract = 10, + Radians = 11, + Degrees = 12, + Sin = 13, + Cos = 14, + Tan = 15, + Asin = 16, + Acos = 17, + Atan = 18, + Sinh = 19, + Cosh = 20, + Tanh = 21, + Asinh = 22, + Acosh = 23, + Atanh = 24, + Atan2 = 25, + Pow = 26, + Exp = 27, + Log = 28, + Exp2 = 29, + Log2 = 30, + Sqrt = 31, + InverseSqrt = 32, + Determinant = 33, + MatrixInverse = 34, + Modf = 35, + ModfStruct = 36, + FMin = 37, + UMin = 38, + SMin = 39, + FMax = 40, + UMax = 41, + SMax = 42, + FClamp = 43, + UClamp = 44, + SClamp = 45, + FMix = 46, + IMix = 47, + Step = 48, + SmoothStep = 49, + Fma = 50, + Frexp = 51, + FrexpStruct = 52, + Ldexp = 53, + PackSnorm4x8 = 54, + PackUnorm4x8 = 55, + PackSnorm2x16 = 56, + PackUnorm2x16 = 57, + PackHalf2x16 = 58, + PackDouble2x32 = 59, + UnpackSnorm2x16 = 60, + UnpackUnorm2x16 = 61, + UnpackHalf2x16 = 62, + UnpackSnorm4x8 = 63, + UnpackUnorm4x8 = 64, + UnpackDouble2x32 = 65, + Length = 66, + Distance = 67, + Cross = 68, + Normalize = 69, + FaceForward = 70, + Reflect = 71, + Refract = 72, + FindILsb = 73, + FindSMsb = 74, + FindUMsb = 75, + InterpolateAtCentroid = 76, + InterpolateAtSample = 77, + InterpolateAtOffset = 78, + NMin = 79, + NMax = 80, + NClamp = 81, + + Max, + Invalid = ~0U, +}; + + +}; // namespace rdcspv + +DECLARE_STRINGISE_TYPE(rdcspv::GLSLstd450); +DECLARE_STRINGISE_TYPE(rdcspv::Generator); + +DECLARE_STRINGISE_TYPE(rdcspv::ImageOperands); +DECLARE_STRINGISE_TYPE(rdcspv::FPFastMathMode); +DECLARE_STRINGISE_TYPE(rdcspv::SelectionControl); +DECLARE_STRINGISE_TYPE(rdcspv::LoopControl); +DECLARE_STRINGISE_TYPE(rdcspv::FunctionControl); +DECLARE_STRINGISE_TYPE(rdcspv::MemorySemantics); +DECLARE_STRINGISE_TYPE(rdcspv::MemoryAccess); +DECLARE_STRINGISE_TYPE(rdcspv::KernelProfilingInfo); +DECLARE_STRINGISE_TYPE(rdcspv::SourceLanguage); +DECLARE_STRINGISE_TYPE(rdcspv::ExecutionModel); +DECLARE_STRINGISE_TYPE(rdcspv::AddressingModel); +DECLARE_STRINGISE_TYPE(rdcspv::MemoryModel); +DECLARE_STRINGISE_TYPE(rdcspv::ExecutionMode); +DECLARE_STRINGISE_TYPE(rdcspv::StorageClass); +DECLARE_STRINGISE_TYPE(rdcspv::Dim); +DECLARE_STRINGISE_TYPE(rdcspv::SamplerAddressingMode); +DECLARE_STRINGISE_TYPE(rdcspv::SamplerFilterMode); +DECLARE_STRINGISE_TYPE(rdcspv::ImageFormat); +DECLARE_STRINGISE_TYPE(rdcspv::ImageChannelOrder); +DECLARE_STRINGISE_TYPE(rdcspv::ImageChannelDataType); +DECLARE_STRINGISE_TYPE(rdcspv::FPRoundingMode); +DECLARE_STRINGISE_TYPE(rdcspv::LinkageType); +DECLARE_STRINGISE_TYPE(rdcspv::AccessQualifier); +DECLARE_STRINGISE_TYPE(rdcspv::FunctionParameterAttribute); +DECLARE_STRINGISE_TYPE(rdcspv::Decoration); +DECLARE_STRINGISE_TYPE(rdcspv::BuiltIn); +DECLARE_STRINGISE_TYPE(rdcspv::Scope); +DECLARE_STRINGISE_TYPE(rdcspv::GroupOperation); +DECLARE_STRINGISE_TYPE(rdcspv::KernelEnqueueFlags); +DECLARE_STRINGISE_TYPE(rdcspv::Capability); diff --git a/renderdoc/driver/shaders/spirv/spirv_op_helpers.h b/renderdoc/driver/shaders/spirv/spirv_op_helpers.h new file mode 100644 index 000000000..609a6fbba --- /dev/null +++ b/renderdoc/driver/shaders/spirv/spirv_op_helpers.h @@ -0,0 +1,16372 @@ +/****************************************************************************** + * The MIT License (MIT) + * + * Copyright (c) 2019 Baldur Karlsson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +/****************************************************************************** + * Generated from Khronos SPIR-V machine-readable JSON grammar. + * + * Copyright (c) 2014-2016 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and/or associated documentation files (the "Materials"), + * to deal in the Materials without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Materials, and to permit persons to whom the + * Materials are furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Materials. + * + * MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS + * STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND + * HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ + * + * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS + * IN THE MATERIALS. + ******************************************************************************/ + +#pragma once + +// This file is autogenerated with gen_spirv_code.py - any changes will be overwritten next time +// that script is run. +// $ ./gen_spirv_code.py + +// We need to disable clang-format since this file is programmatically generated +// clang-format off + +#include +#include +#include "api/replay/renderdoc_replay.h" + +#undef None +#undef CopyMemory +#undef MemoryBarrier + +#include "spirv_common.h" +#include "spirv_gen.h" + +namespace rdcspv +{ + +template +Type DecodeParam(const ConstIter &it, uint32_t &word); + +template<> +inline uint32_t DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return 0; + + uint32_t ret = it.word(word); + word += 1; + return ret; +} + +template<> +inline Id DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return Id(); + + Id ret = Id::fromWord(it.word(word)); + word += 1; + return ret; +} + +template<> +inline rdcstr DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return ""; + + rdcstr ret = (const char *)&it.word(word); + word += uint32_t(ret.size() / 4) + 1; + return ret; +} + +template +rdcarray MultiParam(const ConstIter &it, uint32_t &word) +{ + rdcarray ret; + while(word < it.size()) + { + Type t = DecodeParam(it, word); + ret.push_back(t); + } + return ret; +} + +inline void EncodeParam(std::vector &words, const rdcstr &str) +{ + size_t i=0, remainingChars = str.size() + 1; + while(remainingChars > 0) + { + uint32_t word = 0; + for(size_t w=0; w < remainingChars && w < 4; w++) + word |= uint32_t(str[i+w]) << (w*8); + words.push_back(word); + + i += 4; + if(remainingChars < 4) + remainingChars = 0; + else + remainingChars -= 4; + } +} + +struct PairLiteralIntegerIdRef { uint32_t first; Id second; }; + +struct PairIdRefLiteralInteger { Id first; uint32_t second; }; + +struct PairIdRefIdRef { Id first, second; }; + + +template<> +inline PairIdRefIdRef DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return {}; + + PairIdRefIdRef ret = { Id::fromWord(it.word(word)), Id::fromWord(it.word(word+1)) }; + word += 2; + return ret; +} + +template<> +inline PairLiteralIntegerIdRef DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return {}; + + PairLiteralIntegerIdRef ret = { it.word(word), Id::fromWord(it.word(word+1)) }; + word += 2; + return ret; +} + +template<> +inline PairIdRefLiteralInteger DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return {}; + + PairIdRefLiteralInteger ret = { Id::fromWord(it.word(word)), it.word(word+1) }; + word += 2; + return ret; +} +template<> +inline ImageOperandsAndParamDatas DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return ImageOperandsAndParamDatas(); + + ImageOperandsAndParamDatas ret((ImageOperands)it.word(word)); + word++; + if(ret.flags & ImageOperands::Bias) + { + ret.bias = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::Lod) + { + ret.lod = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::Grad) + { + ret.grad.first = Id::fromWord(it.word(word+0)); + ret.grad.second = Id::fromWord(it.word(word+1)); + word += 2; + } + if(ret.flags & ImageOperands::ConstOffset) + { + ret.constOffset = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::Offset) + { + ret.offset = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::ConstOffsets) + { + ret.constOffsets = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::Sample) + { + ret.sample = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::MinLod) + { + ret.minLod = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::MakeTexelAvailableKHR) + { + ret.makeTexelAvailableKHR = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & ImageOperands::MakeTexelVisibleKHR) + { + ret.makeTexelVisibleKHR = Id::fromWord(it.word(word)); + word += 1; + } + return ret; +} + +inline void EncodeParam(std::vector &words, const ImageOperandsAndParamDatas ¶m) +{ + words.push_back((uint32_t)param.flags); + if(param.flags & ImageOperands::Bias) + { + words.push_back(param.bias.value()); + } + if(param.flags & ImageOperands::Lod) + { + words.push_back(param.lod.value()); + } + if(param.flags & ImageOperands::Grad) + { + words.push_back(param.grad.first.value()); + words.push_back(param.grad.second.value()); + } + if(param.flags & ImageOperands::ConstOffset) + { + words.push_back(param.constOffset.value()); + } + if(param.flags & ImageOperands::Offset) + { + words.push_back(param.offset.value()); + } + if(param.flags & ImageOperands::ConstOffsets) + { + words.push_back(param.constOffsets.value()); + } + if(param.flags & ImageOperands::Sample) + { + words.push_back(param.sample.value()); + } + if(param.flags & ImageOperands::MinLod) + { + words.push_back(param.minLod.value()); + } + if(param.flags & ImageOperands::MakeTexelAvailableKHR) + { + words.push_back(param.makeTexelAvailableKHR.value()); + } + if(param.flags & ImageOperands::MakeTexelVisibleKHR) + { + words.push_back(param.makeTexelVisibleKHR.value()); + } +} + +inline uint16_t ExtraWordCount(const ImageOperands imageOperands) +{ + switch(imageOperands) + { + case ImageOperands::Bias: return 1; + case ImageOperands::Lod: return 1; + case ImageOperands::Grad: return 2; + case ImageOperands::ConstOffset: return 1; + case ImageOperands::Offset: return 1; + case ImageOperands::ConstOffsets: return 1; + case ImageOperands::Sample: return 1; + case ImageOperands::MinLod: return 1; + case ImageOperands::MakeTexelAvailableKHR: return 1; + case ImageOperands::MakeTexelVisibleKHR: return 1; + default: break; + } + return 0; +} + +template<> +inline LoopControlAndParamDatas DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return LoopControlAndParamDatas(); + + LoopControlAndParamDatas ret((LoopControl)it.word(word)); + word++; + if(ret.flags & LoopControl::DependencyLength) + { + ret.dependencyLength = (uint32_t)it.word(word); + word += 1; + } + if(ret.flags & LoopControl::MinIterations) + { + ret.minIterations = (uint32_t)it.word(word); + word += 1; + } + if(ret.flags & LoopControl::MaxIterations) + { + ret.maxIterations = (uint32_t)it.word(word); + word += 1; + } + if(ret.flags & LoopControl::IterationMultiple) + { + ret.iterationMultiple = (uint32_t)it.word(word); + word += 1; + } + if(ret.flags & LoopControl::PeelCount) + { + ret.peelCount = (uint32_t)it.word(word); + word += 1; + } + if(ret.flags & LoopControl::PartialCount) + { + ret.partialCount = (uint32_t)it.word(word); + word += 1; + } + return ret; +} + +inline void EncodeParam(std::vector &words, const LoopControlAndParamDatas ¶m) +{ + words.push_back((uint32_t)param.flags); + if(param.flags & LoopControl::DependencyLength) + { + words.push_back((uint32_t)param.dependencyLength); + } + if(param.flags & LoopControl::MinIterations) + { + words.push_back((uint32_t)param.minIterations); + } + if(param.flags & LoopControl::MaxIterations) + { + words.push_back((uint32_t)param.maxIterations); + } + if(param.flags & LoopControl::IterationMultiple) + { + words.push_back((uint32_t)param.iterationMultiple); + } + if(param.flags & LoopControl::PeelCount) + { + words.push_back((uint32_t)param.peelCount); + } + if(param.flags & LoopControl::PartialCount) + { + words.push_back((uint32_t)param.partialCount); + } +} + +inline uint16_t ExtraWordCount(const LoopControl loopControl) +{ + switch(loopControl) + { + case LoopControl::DependencyLength: return 1; + case LoopControl::MinIterations: return 1; + case LoopControl::MaxIterations: return 1; + case LoopControl::IterationMultiple: return 1; + case LoopControl::PeelCount: return 1; + case LoopControl::PartialCount: return 1; + default: break; + } + return 0; +} + +template<> +inline MemoryAccessAndParamDatas DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return MemoryAccessAndParamDatas(); + + MemoryAccessAndParamDatas ret((MemoryAccess)it.word(word)); + word++; + if(ret.flags & MemoryAccess::Aligned) + { + ret.aligned = (uint32_t)it.word(word); + word += 1; + } + if(ret.flags & MemoryAccess::MakePointerAvailableKHR) + { + ret.makePointerAvailableKHR = Id::fromWord(it.word(word)); + word += 1; + } + if(ret.flags & MemoryAccess::MakePointerVisibleKHR) + { + ret.makePointerVisibleKHR = Id::fromWord(it.word(word)); + word += 1; + } + return ret; +} + +inline void EncodeParam(std::vector &words, const MemoryAccessAndParamDatas ¶m) +{ + words.push_back((uint32_t)param.flags); + if(param.flags & MemoryAccess::Aligned) + { + words.push_back((uint32_t)param.aligned); + } + if(param.flags & MemoryAccess::MakePointerAvailableKHR) + { + words.push_back(param.makePointerAvailableKHR.value()); + } + if(param.flags & MemoryAccess::MakePointerVisibleKHR) + { + words.push_back(param.makePointerVisibleKHR.value()); + } +} + +inline uint16_t ExtraWordCount(const MemoryAccess memoryAccess) +{ + switch(memoryAccess) + { + case MemoryAccess::Aligned: return 1; + case MemoryAccess::MakePointerAvailableKHR: return 1; + case MemoryAccess::MakePointerVisibleKHR: return 1; + default: break; + } + return 0; +} + +inline uint16_t OptionalWordCount(const SourceLanguage val) { return val != SourceLanguage::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const ExecutionModel val) { return val != ExecutionModel::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const AddressingModel val) { return val != AddressingModel::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const MemoryModel val) { return val != MemoryModel::Invalid ? 1 : 0; } + +template struct ExecutionModeParam; + +template<> +struct ExecutionModeParam +{ + uint32_t invocations; + ExecutionModeParam(uint32_t invocationsParam) { invocations = invocationsParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::Invocations); + ret.invocations = invocations; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + LocalSizeParams localSize; + ExecutionModeParam(uint32_t xsize, uint32_t ysize, uint32_t zsize) { localSize.xsize = xsize; localSize.ysize = ysize; localSize.zsize = zsize; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::LocalSize); + ret.localSize.xsize = localSize.xsize; + ret.localSize.ysize = localSize.ysize; + ret.localSize.zsize = localSize.zsize; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + LocalSizeHintParams localSizeHint; + ExecutionModeParam(uint32_t xsize, uint32_t ysize, uint32_t zsize) { localSizeHint.xsize = xsize; localSizeHint.ysize = ysize; localSizeHint.zsize = zsize; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::LocalSizeHint); + ret.localSizeHint.xsize = localSizeHint.xsize; + ret.localSizeHint.ysize = localSizeHint.ysize; + ret.localSizeHint.zsize = localSizeHint.zsize; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t outputVertices; + ExecutionModeParam(uint32_t outputVerticesParam) { outputVertices = outputVerticesParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::OutputVertices); + ret.outputVertices = outputVertices; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t vecTypeHint; + ExecutionModeParam(uint32_t vecTypeHintParam) { vecTypeHint = vecTypeHintParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::VecTypeHint); + ret.vecTypeHint = vecTypeHint; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t subgroupSize; + ExecutionModeParam(uint32_t subgroupSizeParam) { subgroupSize = subgroupSizeParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::SubgroupSize); + ret.subgroupSize = subgroupSize; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t subgroupsPerWorkgroup; + ExecutionModeParam(uint32_t subgroupsPerWorkgroupParam) { subgroupsPerWorkgroup = subgroupsPerWorkgroupParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::SubgroupsPerWorkgroup); + ret.subgroupsPerWorkgroup = subgroupsPerWorkgroup; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + Id subgroupsPerWorkgroupId; + ExecutionModeParam(Id subgroupsPerWorkgroupIdParam) { subgroupsPerWorkgroupId = subgroupsPerWorkgroupIdParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::SubgroupsPerWorkgroupId); + ret.subgroupsPerWorkgroupId = subgroupsPerWorkgroupId; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + LocalSizeIdParams localSizeId; + ExecutionModeParam(Id xsize, Id ysize, Id zsize) { localSizeId.xsize = xsize; localSizeId.ysize = ysize; localSizeId.zsize = zsize; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::LocalSizeId); + ret.localSizeId.xsize = localSizeId.xsize; + ret.localSizeId.ysize = localSizeId.ysize; + ret.localSizeId.zsize = localSizeId.zsize; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + Id localSizeHintId; + ExecutionModeParam(Id localSizeHintIdParam) { localSizeHintId = localSizeHintIdParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::LocalSizeHintId); + ret.localSizeHintId = localSizeHintId; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t denormPreserve; + ExecutionModeParam(uint32_t denormPreserveParam) { denormPreserve = denormPreserveParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::DenormPreserve); + ret.denormPreserve = denormPreserve; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t denormFlushToZero; + ExecutionModeParam(uint32_t denormFlushToZeroParam) { denormFlushToZero = denormFlushToZeroParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::DenormFlushToZero); + ret.denormFlushToZero = denormFlushToZero; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t signedZeroInfNanPreserve; + ExecutionModeParam(uint32_t signedZeroInfNanPreserveParam) { signedZeroInfNanPreserve = signedZeroInfNanPreserveParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::SignedZeroInfNanPreserve); + ret.signedZeroInfNanPreserve = signedZeroInfNanPreserve; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t roundingModeRTE; + ExecutionModeParam(uint32_t roundingModeRTEParam) { roundingModeRTE = roundingModeRTEParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::RoundingModeRTE); + ret.roundingModeRTE = roundingModeRTE; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t roundingModeRTZ; + ExecutionModeParam(uint32_t roundingModeRTZParam) { roundingModeRTZ = roundingModeRTZParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::RoundingModeRTZ); + ret.roundingModeRTZ = roundingModeRTZ; + return ret; + } +}; + +template<> +struct ExecutionModeParam +{ + uint32_t outputPrimitivesNV; + ExecutionModeParam(uint32_t outputPrimitivesNVParam) { outputPrimitivesNV = outputPrimitivesNVParam; } + operator ExecutionModeAndParamData() + { + ExecutionModeAndParamData ret(ExecutionMode::OutputPrimitivesNV); + ret.outputPrimitivesNV = outputPrimitivesNV; + return ret; + } +}; + + + +template<> +inline ExecutionModeAndParamData DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return ExecutionModeAndParamData(); + + ExecutionModeAndParamData ret((ExecutionMode)it.word(word)); + word++; + switch(ret.value) + { + case ExecutionMode::Invocations: + ret.invocations = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::LocalSize: + ret.localSize.xsize = (uint32_t)it.word(word+0); + ret.localSize.ysize = (uint32_t)it.word(word+1); + ret.localSize.zsize = (uint32_t)it.word(word+2); + word += 3; + break; + case ExecutionMode::LocalSizeHint: + ret.localSizeHint.xsize = (uint32_t)it.word(word+0); + ret.localSizeHint.ysize = (uint32_t)it.word(word+1); + ret.localSizeHint.zsize = (uint32_t)it.word(word+2); + word += 3; + break; + case ExecutionMode::OutputVertices: + ret.outputVertices = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::VecTypeHint: + ret.vecTypeHint = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::SubgroupSize: + ret.subgroupSize = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::SubgroupsPerWorkgroup: + ret.subgroupsPerWorkgroup = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::SubgroupsPerWorkgroupId: + ret.subgroupsPerWorkgroupId = Id::fromWord(it.word(word)); + word += 1; + break; + case ExecutionMode::LocalSizeId: + ret.localSizeId.xsize = Id::fromWord(it.word(word+0)); + ret.localSizeId.ysize = Id::fromWord(it.word(word+1)); + ret.localSizeId.zsize = Id::fromWord(it.word(word+2)); + word += 3; + break; + case ExecutionMode::LocalSizeHintId: + ret.localSizeHintId = Id::fromWord(it.word(word)); + word += 1; + break; + case ExecutionMode::DenormPreserve: + ret.denormPreserve = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::DenormFlushToZero: + ret.denormFlushToZero = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::SignedZeroInfNanPreserve: + ret.signedZeroInfNanPreserve = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::RoundingModeRTE: + ret.roundingModeRTE = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::RoundingModeRTZ: + ret.roundingModeRTZ = (uint32_t)it.word(word); + word += 1; + break; + case ExecutionMode::OutputPrimitivesNV: + ret.outputPrimitivesNV = (uint32_t)it.word(word); + word += 1; + break; + default: break; + } + return ret; +} + +inline void EncodeParam(std::vector &words, const ExecutionModeAndParamData ¶m) +{ + words.push_back((uint32_t)param.value); + switch(param.value) + { + case ExecutionMode::Invocations: + words.push_back((uint32_t)param.invocations); + break; + case ExecutionMode::LocalSize: + words.push_back((uint32_t)param.localSize.xsize); + words.push_back((uint32_t)param.localSize.ysize); + words.push_back((uint32_t)param.localSize.zsize); + break; + case ExecutionMode::LocalSizeHint: + words.push_back((uint32_t)param.localSizeHint.xsize); + words.push_back((uint32_t)param.localSizeHint.ysize); + words.push_back((uint32_t)param.localSizeHint.zsize); + break; + case ExecutionMode::OutputVertices: + words.push_back((uint32_t)param.outputVertices); + break; + case ExecutionMode::VecTypeHint: + words.push_back((uint32_t)param.vecTypeHint); + break; + case ExecutionMode::SubgroupSize: + words.push_back((uint32_t)param.subgroupSize); + break; + case ExecutionMode::SubgroupsPerWorkgroup: + words.push_back((uint32_t)param.subgroupsPerWorkgroup); + break; + case ExecutionMode::SubgroupsPerWorkgroupId: + words.push_back(param.subgroupsPerWorkgroupId.value()); + break; + case ExecutionMode::LocalSizeId: + words.push_back(param.localSizeId.xsize.value()); + words.push_back(param.localSizeId.ysize.value()); + words.push_back(param.localSizeId.zsize.value()); + break; + case ExecutionMode::LocalSizeHintId: + words.push_back(param.localSizeHintId.value()); + break; + case ExecutionMode::DenormPreserve: + words.push_back((uint32_t)param.denormPreserve); + break; + case ExecutionMode::DenormFlushToZero: + words.push_back((uint32_t)param.denormFlushToZero); + break; + case ExecutionMode::SignedZeroInfNanPreserve: + words.push_back((uint32_t)param.signedZeroInfNanPreserve); + break; + case ExecutionMode::RoundingModeRTE: + words.push_back((uint32_t)param.roundingModeRTE); + break; + case ExecutionMode::RoundingModeRTZ: + words.push_back((uint32_t)param.roundingModeRTZ); + break; + case ExecutionMode::OutputPrimitivesNV: + words.push_back((uint32_t)param.outputPrimitivesNV); + break; + default: break; + } +} + +inline uint16_t ExtraWordCount(const ExecutionMode executionMode) +{ + switch(executionMode) + { + case ExecutionMode::Invocations: return 1; + case ExecutionMode::LocalSize: return 3; + case ExecutionMode::LocalSizeHint: return 3; + case ExecutionMode::OutputVertices: return 1; + case ExecutionMode::VecTypeHint: return 1; + case ExecutionMode::SubgroupSize: return 1; + case ExecutionMode::SubgroupsPerWorkgroup: return 1; + case ExecutionMode::SubgroupsPerWorkgroupId: return 1; + case ExecutionMode::LocalSizeId: return 3; + case ExecutionMode::LocalSizeHintId: return 1; + case ExecutionMode::DenormPreserve: return 1; + case ExecutionMode::DenormFlushToZero: return 1; + case ExecutionMode::SignedZeroInfNanPreserve: return 1; + case ExecutionMode::RoundingModeRTE: return 1; + case ExecutionMode::RoundingModeRTZ: return 1; + case ExecutionMode::OutputPrimitivesNV: return 1; + default: break; + } + return 0; +} + +inline uint16_t OptionalWordCount(const StorageClass val) { return val != StorageClass::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const Dim val) { return val != Dim::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const SamplerAddressingMode val) { return val != SamplerAddressingMode::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const SamplerFilterMode val) { return val != SamplerFilterMode::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const ImageFormat val) { return val != ImageFormat::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const ImageChannelOrder val) { return val != ImageChannelOrder::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const ImageChannelDataType val) { return val != ImageChannelDataType::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const FPRoundingMode val) { return val != FPRoundingMode::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const LinkageType val) { return val != LinkageType::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const AccessQualifier val) { return val != AccessQualifier::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const FunctionParameterAttribute val) { return val != FunctionParameterAttribute::Invalid ? 1 : 0; } + +template struct DecorationParam; + +template<> +struct DecorationParam +{ + uint32_t specId; + DecorationParam(uint32_t specIdParam) { specId = specIdParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::SpecId); + ret.specId = specId; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t arrayStride; + DecorationParam(uint32_t arrayStrideParam) { arrayStride = arrayStrideParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::ArrayStride); + ret.arrayStride = arrayStride; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t matrixStride; + DecorationParam(uint32_t matrixStrideParam) { matrixStride = matrixStrideParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::MatrixStride); + ret.matrixStride = matrixStride; + return ret; + } +}; + +template<> +struct DecorationParam +{ + BuiltIn builtIn; + DecorationParam(BuiltIn builtInParam) { builtIn = builtInParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::BuiltIn); + ret.builtIn = builtIn; + return ret; + } +}; + +template<> +struct DecorationParam +{ + IdScope uniformId; + DecorationParam(IdScope uniformIdParam) { uniformId = uniformIdParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::UniformId); + ret.uniformId = uniformId; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t stream; + DecorationParam(uint32_t streamParam) { stream = streamParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Stream); + ret.stream = stream; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t location; + DecorationParam(uint32_t locationParam) { location = locationParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Location); + ret.location = location; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t component; + DecorationParam(uint32_t componentParam) { component = componentParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Component); + ret.component = component; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t index; + DecorationParam(uint32_t indexParam) { index = indexParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Index); + ret.index = index; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t binding; + DecorationParam(uint32_t bindingParam) { binding = bindingParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Binding); + ret.binding = binding; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t descriptorSet; + DecorationParam(uint32_t descriptorSetParam) { descriptorSet = descriptorSetParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::DescriptorSet); + ret.descriptorSet = descriptorSet; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t offset; + DecorationParam(uint32_t offsetParam) { offset = offsetParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Offset); + ret.offset = offset; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t xfbBuffer; + DecorationParam(uint32_t xfbBufferParam) { xfbBuffer = xfbBufferParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::XfbBuffer); + ret.xfbBuffer = xfbBuffer; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t xfbStride; + DecorationParam(uint32_t xfbStrideParam) { xfbStride = xfbStrideParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::XfbStride); + ret.xfbStride = xfbStride; + return ret; + } +}; + +template<> +struct DecorationParam +{ + FunctionParameterAttribute funcParamAttr; + DecorationParam(FunctionParameterAttribute funcParamAttrParam) { funcParamAttr = funcParamAttrParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::FuncParamAttr); + ret.funcParamAttr = funcParamAttr; + return ret; + } +}; + +template<> +struct DecorationParam +{ + FPRoundingMode fPRoundingMode; + DecorationParam(FPRoundingMode fPRoundingModeParam) { fPRoundingMode = fPRoundingModeParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::FPRoundingMode); + ret.fPRoundingMode = fPRoundingMode; + return ret; + } +}; + +template<> +struct DecorationParam +{ + FPFastMathMode fPFastMathMode; + DecorationParam(FPFastMathMode fPFastMathModeParam) { fPFastMathMode = fPFastMathModeParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::FPFastMathMode); + ret.fPFastMathMode = fPFastMathMode; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t inputAttachmentIndex; + DecorationParam(uint32_t inputAttachmentIndexParam) { inputAttachmentIndex = inputAttachmentIndexParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::InputAttachmentIndex); + ret.inputAttachmentIndex = inputAttachmentIndex; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t alignment; + DecorationParam(uint32_t alignmentParam) { alignment = alignmentParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::Alignment); + ret.alignment = alignment; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t maxByteOffset; + DecorationParam(uint32_t maxByteOffsetParam) { maxByteOffset = maxByteOffsetParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::MaxByteOffset); + ret.maxByteOffset = maxByteOffset; + return ret; + } +}; + +template<> +struct DecorationParam +{ + Id alignmentId; + DecorationParam(Id alignmentIdParam) { alignmentId = alignmentIdParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::AlignmentId); + ret.alignmentId = alignmentId; + return ret; + } +}; + +template<> +struct DecorationParam +{ + Id maxByteOffsetId; + DecorationParam(Id maxByteOffsetIdParam) { maxByteOffsetId = maxByteOffsetIdParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::MaxByteOffsetId); + ret.maxByteOffsetId = maxByteOffsetId; + return ret; + } +}; + +template<> +struct DecorationParam +{ + uint32_t secondaryViewportRelativeNV; + DecorationParam(uint32_t secondaryViewportRelativeNVParam) { secondaryViewportRelativeNV = secondaryViewportRelativeNVParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::SecondaryViewportRelativeNV); + ret.secondaryViewportRelativeNV = secondaryViewportRelativeNV; + return ret; + } +}; + +template<> +struct DecorationParam +{ + Id counterBuffer; + DecorationParam(Id counterBufferParam) { counterBuffer = counterBufferParam; } + operator DecorationAndParamData() + { + DecorationAndParamData ret(Decoration::CounterBuffer); + ret.counterBuffer = counterBuffer; + return ret; + } +}; + + + +template<> +inline DecorationAndParamData DecodeParam(const ConstIter &it, uint32_t &word) +{ + if(word >= it.size()) return DecorationAndParamData(); + + DecorationAndParamData ret((Decoration)it.word(word)); + word++; + switch(ret.value) + { + case Decoration::SpecId: + ret.specId = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::ArrayStride: + ret.arrayStride = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::MatrixStride: + ret.matrixStride = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::BuiltIn: + ret.builtIn = (BuiltIn)it.word(word); + word += 1; + break; + case Decoration::UniformId: + ret.uniformId = Id::fromWord(it.word(word)); + word += 1; + break; + case Decoration::Stream: + ret.stream = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::Location: + ret.location = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::Component: + ret.component = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::Index: + ret.index = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::Binding: + ret.binding = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::DescriptorSet: + ret.descriptorSet = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::Offset: + ret.offset = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::XfbBuffer: + ret.xfbBuffer = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::XfbStride: + ret.xfbStride = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::FuncParamAttr: + ret.funcParamAttr = (FunctionParameterAttribute)it.word(word); + word += 1; + break; + case Decoration::FPRoundingMode: + ret.fPRoundingMode = (FPRoundingMode)it.word(word); + word += 1; + break; + case Decoration::FPFastMathMode: + ret.fPFastMathMode = (FPFastMathMode)it.word(word); + word += 1; + break; + case Decoration::InputAttachmentIndex: + ret.inputAttachmentIndex = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::Alignment: + ret.alignment = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::MaxByteOffset: + ret.maxByteOffset = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::AlignmentId: + ret.alignmentId = Id::fromWord(it.word(word)); + word += 1; + break; + case Decoration::MaxByteOffsetId: + ret.maxByteOffsetId = Id::fromWord(it.word(word)); + word += 1; + break; + case Decoration::SecondaryViewportRelativeNV: + ret.secondaryViewportRelativeNV = (uint32_t)it.word(word); + word += 1; + break; + case Decoration::CounterBuffer: + ret.counterBuffer = Id::fromWord(it.word(word)); + word += 1; + break; + default: break; + } + return ret; +} + +inline void EncodeParam(std::vector &words, const DecorationAndParamData ¶m) +{ + words.push_back((uint32_t)param.value); + switch(param.value) + { + case Decoration::SpecId: + words.push_back((uint32_t)param.specId); + break; + case Decoration::ArrayStride: + words.push_back((uint32_t)param.arrayStride); + break; + case Decoration::MatrixStride: + words.push_back((uint32_t)param.matrixStride); + break; + case Decoration::BuiltIn: + words.push_back((uint32_t)param.builtIn); + break; + case Decoration::UniformId: + words.push_back(param.uniformId.value()); + break; + case Decoration::Stream: + words.push_back((uint32_t)param.stream); + break; + case Decoration::Location: + words.push_back((uint32_t)param.location); + break; + case Decoration::Component: + words.push_back((uint32_t)param.component); + break; + case Decoration::Index: + words.push_back((uint32_t)param.index); + break; + case Decoration::Binding: + words.push_back((uint32_t)param.binding); + break; + case Decoration::DescriptorSet: + words.push_back((uint32_t)param.descriptorSet); + break; + case Decoration::Offset: + words.push_back((uint32_t)param.offset); + break; + case Decoration::XfbBuffer: + words.push_back((uint32_t)param.xfbBuffer); + break; + case Decoration::XfbStride: + words.push_back((uint32_t)param.xfbStride); + break; + case Decoration::FuncParamAttr: + words.push_back((uint32_t)param.funcParamAttr); + break; + case Decoration::FPRoundingMode: + words.push_back((uint32_t)param.fPRoundingMode); + break; + case Decoration::FPFastMathMode: + words.push_back((uint32_t)param.fPFastMathMode); + break; + case Decoration::InputAttachmentIndex: + words.push_back((uint32_t)param.inputAttachmentIndex); + break; + case Decoration::Alignment: + words.push_back((uint32_t)param.alignment); + break; + case Decoration::MaxByteOffset: + words.push_back((uint32_t)param.maxByteOffset); + break; + case Decoration::AlignmentId: + words.push_back(param.alignmentId.value()); + break; + case Decoration::MaxByteOffsetId: + words.push_back(param.maxByteOffsetId.value()); + break; + case Decoration::SecondaryViewportRelativeNV: + words.push_back((uint32_t)param.secondaryViewportRelativeNV); + break; + case Decoration::CounterBuffer: + words.push_back(param.counterBuffer.value()); + break; + default: break; + } +} + +inline uint16_t ExtraWordCount(const Decoration decoration) +{ + switch(decoration) + { + case Decoration::SpecId: return 1; + case Decoration::ArrayStride: return 1; + case Decoration::MatrixStride: return 1; + case Decoration::BuiltIn: return 1; + case Decoration::UniformId: return 1; + case Decoration::Stream: return 1; + case Decoration::Location: return 1; + case Decoration::Component: return 1; + case Decoration::Index: return 1; + case Decoration::Binding: return 1; + case Decoration::DescriptorSet: return 1; + case Decoration::Offset: return 1; + case Decoration::XfbBuffer: return 1; + case Decoration::XfbStride: return 1; + case Decoration::FuncParamAttr: return 1; + case Decoration::FPRoundingMode: return 1; + case Decoration::FPFastMathMode: return 1; + case Decoration::InputAttachmentIndex: return 1; + case Decoration::Alignment: return 1; + case Decoration::MaxByteOffset: return 1; + case Decoration::AlignmentId: return 1; + case Decoration::MaxByteOffsetId: return 1; + case Decoration::SecondaryViewportRelativeNV: return 1; + case Decoration::CounterBuffer: return 1; + default: break; + } + return 0; +} + +inline uint16_t OptionalWordCount(const BuiltIn val) { return val != BuiltIn::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const Scope val) { return val != Scope::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const GroupOperation val) { return val != GroupOperation::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const KernelEnqueueFlags val) { return val != KernelEnqueueFlags::Invalid ? 1 : 0; } + +inline uint16_t OptionalWordCount(const Capability val) { return val != Capability::Invalid ? 1 : 0; } + + +inline uint16_t ExtraWordCount(const rdcstr &val) +{ + return uint16_t(val.size() / 4); +} + +inline uint16_t OptionalWordCount(const rdcstr &val) +{ + if(val.empty()) return 0; + return uint16_t(val.size() / 4) + 1; +} + +inline uint16_t OptionalWordCount(const Id &val) +{ + return val != Id() ? 1 : 0; +} + +inline uint16_t OptionalWordCount(const PairIdRefLiteralInteger &val) +{ + return val.first != Id() ? 2 : 0; +} + +inline uint16_t OptionalWordCount(const PairLiteralIntegerIdRef &val) +{ + return val.second != Id() ? 2 : 0; +} + +inline uint16_t OptionalWordCount(const PairIdRefIdRef &val) +{ + return val.first != Id() ? 2 : 0; +} + +template +uint16_t MultiWordCount(const rdcarray &multiParams) +{ + uint16_t ret = 0; + for(size_t i=0; i < multiParams.size(); i++) + ret += sizeof(multiParams[i])/sizeof(uint32_t); + return ret; +} + +struct OpNop +{ + OpNop(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpNop() + : op(Op::Nop) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::Nop; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpUndef +{ + OpUndef(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUndef(IdResultType resultType, IdResult result) + : op(Op::Undef) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::Undef; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSourceContinued +{ + OpSourceContinued(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + uint32_t word = 1; + this->continuedSource = DecodeParam(it, word); + } + OpSourceContinued(rdcstr continuedSource) + : op(Op::SourceContinued) + , wordCount(MinWordSize + ExtraWordCount(continuedSource)) + { + this->continuedSource = continuedSource; + } + operator Operation() const + { + std::vector words; + EncodeParam(words, continuedSource); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::SourceContinued; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + rdcstr continuedSource; +}; + +struct OpSource +{ + OpSource(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->sourceLanguage = (SourceLanguage)it.word(1); + this->version = (uint32_t)it.word(2); + this->file = (it.size() > 3) ? Id::fromWord(it.word(3)) : Id(); + uint32_t word = 4; + this->source = DecodeParam(it, word); + } + OpSource(SourceLanguage sourceLanguage, uint32_t version, Id file = Id(), rdcstr source = "") + : op(Op::Source) + , wordCount(MinWordSize + OptionalWordCount(source)) + { + this->sourceLanguage = sourceLanguage; + this->version = version; + this->file = file; + this->source = source; + } + operator Operation() const + { + std::vector words; + words.push_back((uint32_t)sourceLanguage); + words.push_back((uint32_t)version); + if(file != Id()) words.push_back(file.value()); + EncodeParam(words, source); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Source; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + SourceLanguage sourceLanguage; + uint32_t version; + Id file; + rdcstr source; + + bool HasFile() const { return wordCount > 3; } + bool HasSource() const { return wordCount > 4; } +}; + +struct OpSourceExtension +{ + OpSourceExtension(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + uint32_t word = 1; + this->extension = DecodeParam(it, word); + } + OpSourceExtension(rdcstr extension) + : op(Op::SourceExtension) + , wordCount(MinWordSize + ExtraWordCount(extension)) + { + this->extension = extension; + } + operator Operation() const + { + std::vector words; + EncodeParam(words, extension); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::SourceExtension; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + rdcstr extension; +}; + +struct OpName +{ + OpName(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->target = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->name = DecodeParam(it, word); + } + OpName(Id target, rdcstr name) + : op(Op::Name) + , wordCount(MinWordSize + ExtraWordCount(name)) + { + this->target = target; + this->name = name; + } + operator Operation() const + { + std::vector words; + words.push_back(target.value()); + EncodeParam(words, name); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Name; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id target; + rdcstr name; +}; + +struct OpMemberName +{ + OpMemberName(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->type = Id::fromWord(it.word(1)); + this->member = (uint32_t)it.word(2); + uint32_t word = 3; + this->name = DecodeParam(it, word); + } + OpMemberName(Id type, uint32_t member, rdcstr name) + : op(Op::MemberName) + , wordCount(MinWordSize + ExtraWordCount(name)) + { + this->type = type; + this->member = member; + this->name = name; + } + operator Operation() const + { + std::vector words; + words.push_back(type.value()); + words.push_back((uint32_t)member); + EncodeParam(words, name); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::MemberName; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id type; + uint32_t member; + rdcstr name; +}; + +struct OpString +{ + OpString(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->result = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->string = DecodeParam(it, word); + } + OpString(IdResult result, rdcstr string) + : op(Op::String) + , wordCount(MinWordSize + ExtraWordCount(string)) + { + this->result = result; + this->string = string; + } + operator Operation() const + { + std::vector words; + words.push_back(result.value()); + EncodeParam(words, string); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::String; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + rdcstr string; +}; + +struct OpLine +{ + OpLine(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLine(Id file, uint32_t line, uint32_t column) + : op(Op::Line) + , wordCount(FixedWordSize) + { + this->file = file; + this->line = line; + this->column = column; + } + + static constexpr Op OpCode = Op::Line; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + Id file; + uint32_t line; + uint32_t column; +}; + +struct OpExtension +{ + OpExtension(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + uint32_t word = 1; + this->name = DecodeParam(it, word); + } + OpExtension(rdcstr name) + : op(Op::Extension) + , wordCount(MinWordSize + ExtraWordCount(name)) + { + this->name = name; + } + operator Operation() const + { + std::vector words; + EncodeParam(words, name); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Extension; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + rdcstr name; +}; + +struct OpExtInstImport +{ + OpExtInstImport(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->result = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->name = DecodeParam(it, word); + } + OpExtInstImport(IdResult result, rdcstr name) + : op(Op::ExtInstImport) + , wordCount(MinWordSize + ExtraWordCount(name)) + { + this->result = result; + this->name = name; + } + operator Operation() const + { + std::vector words; + words.push_back(result.value()); + EncodeParam(words, name); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ExtInstImport; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + rdcstr name; +}; + +struct OpExtInst; // has operands with variable sizes + +struct OpMemoryModel +{ + OpMemoryModel(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpMemoryModel(AddressingModel addressingModel, MemoryModel memoryModel) + : op(Op::MemoryModel) + , wordCount(FixedWordSize) + { + this->addressingModel = addressingModel; + this->memoryModel = memoryModel; + } + + static constexpr Op OpCode = Op::MemoryModel; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + AddressingModel addressingModel; + MemoryModel memoryModel; +}; + +struct OpEntryPoint +{ + OpEntryPoint(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->executionModel = (ExecutionModel)it.word(1); + this->entryPoint = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->name = DecodeParam(it, word); + this->iface = MultiParam(it, word); + } + OpEntryPoint(ExecutionModel executionModel, Id entryPoint, rdcstr name, const rdcarray &iface = {}) + : op(Op::EntryPoint) + , wordCount(MinWordSize + ExtraWordCount(name) + MultiWordCount(iface)) + { + this->executionModel = executionModel; + this->entryPoint = entryPoint; + this->name = name; + this->iface = iface; + } + operator Operation() const + { + std::vector words; + words.push_back((uint32_t)executionModel); + words.push_back(entryPoint.value()); + EncodeParam(words, name); + for(size_t i=0; i < iface.size(); i++) + { + words.push_back(iface[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::EntryPoint; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + ExecutionModel executionModel; + Id entryPoint; + rdcstr name; + rdcarray iface; +}; + +struct OpExecutionMode +{ + OpExecutionMode(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->entryPoint = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->mode = DecodeParam(it, word); + } + OpExecutionMode(Id entryPoint, ExecutionModeAndParamData mode) + : op(Op::ExecutionMode) + , wordCount(MinWordSize + ExtraWordCount(mode)) + { + this->entryPoint = entryPoint; + this->mode = mode; + } + operator Operation() const + { + std::vector words; + words.push_back(entryPoint.value()); + EncodeParam(words, mode); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ExecutionMode; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id entryPoint; + ExecutionModeAndParamData mode; +}; + +struct OpCapability +{ + OpCapability(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCapability(Capability capability) + : op(Op::Capability) + , wordCount(FixedWordSize) + { + this->capability = capability; + } + + static constexpr Op OpCode = Op::Capability; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Capability capability; +}; + +struct OpTypeVoid +{ + OpTypeVoid(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeVoid(IdResult result) + : op(Op::TypeVoid) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeVoid; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeBool +{ + OpTypeBool(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeBool(IdResult result) + : op(Op::TypeBool) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeBool; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeInt +{ + OpTypeInt(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeInt(IdResult result, uint32_t width, uint32_t signedness) + : op(Op::TypeInt) + , wordCount(FixedWordSize) + { + this->result = result; + this->width = width; + this->signedness = signedness; + } + + static constexpr Op OpCode = Op::TypeInt; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResult result; + uint32_t width; + uint32_t signedness; +}; + +struct OpTypeFloat +{ + OpTypeFloat(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeFloat(IdResult result, uint32_t width) + : op(Op::TypeFloat) + , wordCount(FixedWordSize) + { + this->result = result; + this->width = width; + } + + static constexpr Op OpCode = Op::TypeFloat; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + uint32_t width; +}; + +struct OpTypeVector +{ + OpTypeVector(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeVector(IdResult result, Id componentType, uint32_t componentCount) + : op(Op::TypeVector) + , wordCount(FixedWordSize) + { + this->result = result; + this->componentType = componentType; + this->componentCount = componentCount; + } + + static constexpr Op OpCode = Op::TypeVector; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResult result; + Id componentType; + uint32_t componentCount; +}; + +struct OpTypeMatrix +{ + OpTypeMatrix(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeMatrix(IdResult result, Id columnType, uint32_t columnCount) + : op(Op::TypeMatrix) + , wordCount(FixedWordSize) + { + this->result = result; + this->columnType = columnType; + this->columnCount = columnCount; + } + + static constexpr Op OpCode = Op::TypeMatrix; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResult result; + Id columnType; + uint32_t columnCount; +}; + +struct OpTypeImage +{ + OpTypeImage(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->result = Id::fromWord(it.word(1)); + this->sampledType = Id::fromWord(it.word(2)); + this->dim = (Dim)it.word(3); + this->depth = (uint32_t)it.word(4); + this->arrayed = (uint32_t)it.word(5); + this->mS = (uint32_t)it.word(6); + this->sampled = (uint32_t)it.word(7); + this->imageFormat = (ImageFormat)it.word(8); + this->accessQualifier = (it.size() > 9) ? (AccessQualifier)it.word(9) : AccessQualifier::Invalid; + } + OpTypeImage(IdResult result, Id sampledType, Dim dim, uint32_t depth, uint32_t arrayed, uint32_t mS, uint32_t sampled, ImageFormat imageFormat, AccessQualifier accessQualifier = AccessQualifier::Invalid) + : op(Op::TypeImage) + , wordCount(MinWordSize + OptionalWordCount(accessQualifier)) + { + this->result = result; + this->sampledType = sampledType; + this->dim = dim; + this->depth = depth; + this->arrayed = arrayed; + this->mS = mS; + this->sampled = sampled; + this->imageFormat = imageFormat; + this->accessQualifier = accessQualifier; + } + operator Operation() const + { + std::vector words; + words.push_back(result.value()); + words.push_back(sampledType.value()); + words.push_back((uint32_t)dim); + words.push_back((uint32_t)depth); + words.push_back((uint32_t)arrayed); + words.push_back((uint32_t)mS); + words.push_back((uint32_t)sampled); + words.push_back((uint32_t)imageFormat); + if(accessQualifier != AccessQualifier::Invalid) words.push_back((uint32_t)accessQualifier); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::TypeImage; + static constexpr uint16_t MinWordSize = 9U; + Op op; + uint16_t wordCount; + IdResult result; + Id sampledType; + Dim dim; + uint32_t depth; + uint32_t arrayed; + uint32_t mS; + uint32_t sampled; + ImageFormat imageFormat; + AccessQualifier accessQualifier; + + bool HasAccessQualifier() const { return wordCount > 9; } +}; + +struct OpTypeSampler +{ + OpTypeSampler(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeSampler(IdResult result) + : op(Op::TypeSampler) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeSampler; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeSampledImage +{ + OpTypeSampledImage(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeSampledImage(IdResult result, Id imageType) + : op(Op::TypeSampledImage) + , wordCount(FixedWordSize) + { + this->result = result; + this->imageType = imageType; + } + + static constexpr Op OpCode = Op::TypeSampledImage; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + Id imageType; +}; + +struct OpTypeArray +{ + OpTypeArray(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeArray(IdResult result, Id elementType, Id length) + : op(Op::TypeArray) + , wordCount(FixedWordSize) + { + this->result = result; + this->elementType = elementType; + this->length = length; + } + + static constexpr Op OpCode = Op::TypeArray; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResult result; + Id elementType; + Id length; +}; + +struct OpTypeRuntimeArray +{ + OpTypeRuntimeArray(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeRuntimeArray(IdResult result, Id elementType) + : op(Op::TypeRuntimeArray) + , wordCount(FixedWordSize) + { + this->result = result; + this->elementType = elementType; + } + + static constexpr Op OpCode = Op::TypeRuntimeArray; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + Id elementType; +}; + +struct OpTypeStruct +{ + OpTypeStruct(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->result = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->members = MultiParam(it, word); + } + OpTypeStruct(IdResult result, const rdcarray &members = {}) + : op(Op::TypeStruct) + , wordCount(MinWordSize + MultiWordCount(members)) + { + this->result = result; + this->members = members; + } + operator Operation() const + { + std::vector words; + words.push_back(result.value()); + for(size_t i=0; i < members.size(); i++) + { + words.push_back(members[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::TypeStruct; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; + rdcarray members; +}; + +struct OpTypeOpaque +{ + OpTypeOpaque(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->result = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->thenameoftheopaquetype = DecodeParam(it, word); + } + OpTypeOpaque(IdResult result, rdcstr thenameoftheopaquetype) + : op(Op::TypeOpaque) + , wordCount(MinWordSize + ExtraWordCount(thenameoftheopaquetype)) + { + this->result = result; + this->thenameoftheopaquetype = thenameoftheopaquetype; + } + operator Operation() const + { + std::vector words; + words.push_back(result.value()); + EncodeParam(words, thenameoftheopaquetype); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::TypeOpaque; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + rdcstr thenameoftheopaquetype; +}; + +struct OpTypePointer +{ + OpTypePointer(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypePointer(IdResult result, StorageClass storageClass, Id type) + : op(Op::TypePointer) + , wordCount(FixedWordSize) + { + this->result = result; + this->storageClass = storageClass; + this->type = type; + } + + static constexpr Op OpCode = Op::TypePointer; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResult result; + StorageClass storageClass; + Id type; +}; + +struct OpTypeFunction +{ + OpTypeFunction(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->result = Id::fromWord(it.word(1)); + this->returnType = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->parameters = MultiParam(it, word); + } + OpTypeFunction(IdResult result, Id returnType, const rdcarray ¶meters = {}) + : op(Op::TypeFunction) + , wordCount(MinWordSize + MultiWordCount(parameters)) + { + this->result = result; + this->returnType = returnType; + this->parameters = parameters; + } + operator Operation() const + { + std::vector words; + words.push_back(result.value()); + words.push_back(returnType.value()); + for(size_t i=0; i < parameters.size(); i++) + { + words.push_back(parameters[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::TypeFunction; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + Id returnType; + rdcarray parameters; +}; + +struct OpTypeEvent +{ + OpTypeEvent(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeEvent(IdResult result) + : op(Op::TypeEvent) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeEvent; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeDeviceEvent +{ + OpTypeDeviceEvent(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeDeviceEvent(IdResult result) + : op(Op::TypeDeviceEvent) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeDeviceEvent; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeReserveId +{ + OpTypeReserveId(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeReserveId(IdResult result) + : op(Op::TypeReserveId) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeReserveId; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeQueue +{ + OpTypeQueue(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeQueue(IdResult result) + : op(Op::TypeQueue) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeQueue; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypePipe +{ + OpTypePipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypePipe(IdResult result, AccessQualifier qualifier) + : op(Op::TypePipe) + , wordCount(FixedWordSize) + { + this->result = result; + this->qualifier = qualifier; + } + + static constexpr Op OpCode = Op::TypePipe; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + AccessQualifier qualifier; +}; + +struct OpTypeForwardPointer +{ + OpTypeForwardPointer(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeForwardPointer(Id pointerType, StorageClass storageClass) + : op(Op::TypeForwardPointer) + , wordCount(FixedWordSize) + { + this->pointerType = pointerType; + this->storageClass = storageClass; + } + + static constexpr Op OpCode = Op::TypeForwardPointer; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id pointerType; + StorageClass storageClass; +}; + +struct OpConstantTrue +{ + OpConstantTrue(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConstantTrue(IdResultType resultType, IdResult result) + : op(Op::ConstantTrue) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::ConstantTrue; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpConstantFalse +{ + OpConstantFalse(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConstantFalse(IdResultType resultType, IdResult result) + : op(Op::ConstantFalse) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::ConstantFalse; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpConstant; // has operands with variable sizes + +struct OpConstantComposite +{ + OpConstantComposite(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->constituents = MultiParam(it, word); + } + OpConstantComposite(IdResultType resultType, IdResult result, const rdcarray &constituents = {}) + : op(Op::ConstantComposite) + , wordCount(MinWordSize + MultiWordCount(constituents)) + { + this->resultType = resultType; + this->result = result; + this->constituents = constituents; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + for(size_t i=0; i < constituents.size(); i++) + { + words.push_back(constituents[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ConstantComposite; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + rdcarray constituents; +}; + +struct OpConstantSampler +{ + OpConstantSampler(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConstantSampler(IdResultType resultType, IdResult result, SamplerAddressingMode samplerAddressingMode, uint32_t param, SamplerFilterMode samplerFilterMode) + : op(Op::ConstantSampler) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->samplerAddressingMode = samplerAddressingMode; + this->param = param; + this->samplerFilterMode = samplerFilterMode; + } + + static constexpr Op OpCode = Op::ConstantSampler; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + SamplerAddressingMode samplerAddressingMode; + uint32_t param; + SamplerFilterMode samplerFilterMode; +}; + +struct OpConstantNull +{ + OpConstantNull(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConstantNull(IdResultType resultType, IdResult result) + : op(Op::ConstantNull) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::ConstantNull; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSpecConstantTrue +{ + OpSpecConstantTrue(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSpecConstantTrue(IdResultType resultType, IdResult result) + : op(Op::SpecConstantTrue) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SpecConstantTrue; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSpecConstantFalse +{ + OpSpecConstantFalse(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSpecConstantFalse(IdResultType resultType, IdResult result) + : op(Op::SpecConstantFalse) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SpecConstantFalse; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSpecConstant; // has operands with variable sizes + +struct OpSpecConstantComposite +{ + OpSpecConstantComposite(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->constituents = MultiParam(it, word); + } + OpSpecConstantComposite(IdResultType resultType, IdResult result, const rdcarray &constituents = {}) + : op(Op::SpecConstantComposite) + , wordCount(MinWordSize + MultiWordCount(constituents)) + { + this->resultType = resultType; + this->result = result; + this->constituents = constituents; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + for(size_t i=0; i < constituents.size(); i++) + { + words.push_back(constituents[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::SpecConstantComposite; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + rdcarray constituents; +}; + +struct OpSpecConstantOp; // has operands with variable sizes + +struct OpFunction +{ + OpFunction(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFunction(IdResultType resultType, IdResult result, FunctionControl functionControl, Id functionType) + : op(Op::Function) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->functionControl = functionControl; + this->functionType = functionType; + } + + static constexpr Op OpCode = Op::Function; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + FunctionControl functionControl; + Id functionType; +}; + +struct OpFunctionParameter +{ + OpFunctionParameter(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFunctionParameter(IdResultType resultType, IdResult result) + : op(Op::FunctionParameter) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::FunctionParameter; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpFunctionEnd +{ + OpFunctionEnd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFunctionEnd() + : op(Op::FunctionEnd) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::FunctionEnd; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpFunctionCall +{ + OpFunctionCall(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->function = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->arguments = MultiParam(it, word); + } + OpFunctionCall(IdResultType resultType, IdResult result, Id function, const rdcarray &arguments = {}) + : op(Op::FunctionCall) + , wordCount(MinWordSize + MultiWordCount(arguments)) + { + this->resultType = resultType; + this->result = result; + this->function = function; + this->arguments = arguments; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(function.value()); + for(size_t i=0; i < arguments.size(); i++) + { + words.push_back(arguments[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::FunctionCall; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id function; + rdcarray arguments; +}; + +struct OpVariable +{ + OpVariable(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->storageClass = (StorageClass)it.word(3); + this->initializer = (it.size() > 4) ? Id::fromWord(it.word(4)) : Id(); + } + OpVariable(IdResultType resultType, IdResult result, StorageClass storageClass, Id initializer = Id()) + : op(Op::Variable) + , wordCount(MinWordSize + OptionalWordCount(initializer)) + { + this->resultType = resultType; + this->result = result; + this->storageClass = storageClass; + this->initializer = initializer; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back((uint32_t)storageClass); + if(initializer != Id()) words.push_back(initializer.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Variable; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + StorageClass storageClass; + Id initializer; + + bool HasInitializer() const { return wordCount > 4; } +}; + +struct OpImageTexelPointer +{ + OpImageTexelPointer(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageTexelPointer(IdResultType resultType, IdResult result, Id image, Id coordinate, Id sample) + : op(Op::ImageTexelPointer) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->sample = sample; + } + + static constexpr Op OpCode = Op::ImageTexelPointer; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + Id sample; +}; + +struct OpLoad +{ + OpLoad(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->pointer = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->memoryAccess = DecodeParam(it, word); + } + OpLoad(IdResultType resultType, IdResult result, Id pointer, MemoryAccessAndParamDatas memoryAccess = MemoryAccess::None) + : op(Op::Load) + , wordCount(MinWordSize + ExtraWordCount(memoryAccess)) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memoryAccess = memoryAccess; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(pointer.value()); + EncodeParam(words, memoryAccess); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Load; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + MemoryAccessAndParamDatas memoryAccess; +}; + +struct OpStore +{ + OpStore(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->pointer = Id::fromWord(it.word(1)); + this->object = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->memoryAccess = DecodeParam(it, word); + } + OpStore(Id pointer, Id object, MemoryAccessAndParamDatas memoryAccess = MemoryAccess::None) + : op(Op::Store) + , wordCount(MinWordSize + ExtraWordCount(memoryAccess)) + { + this->pointer = pointer; + this->object = object; + this->memoryAccess = memoryAccess; + } + operator Operation() const + { + std::vector words; + words.push_back(pointer.value()); + words.push_back(object.value()); + EncodeParam(words, memoryAccess); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Store; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id pointer; + Id object; + MemoryAccessAndParamDatas memoryAccess; +}; + +struct OpCopyMemory +{ + OpCopyMemory(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->target = Id::fromWord(it.word(1)); + this->source = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->memoryAccess0 = DecodeParam(it, word); + this->memoryAccess1 = DecodeParam(it, word); + } + OpCopyMemory(Id target, Id source, MemoryAccessAndParamDatas memoryAccess0 = MemoryAccess::None, MemoryAccessAndParamDatas memoryAccess1 = MemoryAccess::None) + : op(Op::CopyMemory) + , wordCount(MinWordSize + ExtraWordCount(memoryAccess0) + ExtraWordCount(memoryAccess1)) + { + this->target = target; + this->source = source; + this->memoryAccess0 = memoryAccess0; + this->memoryAccess1 = memoryAccess1; + } + operator Operation() const + { + std::vector words; + words.push_back(target.value()); + words.push_back(source.value()); + EncodeParam(words, memoryAccess0); + EncodeParam(words, memoryAccess1); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CopyMemory; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id target; + Id source; + MemoryAccessAndParamDatas memoryAccess0; + MemoryAccessAndParamDatas memoryAccess1; +}; + +struct OpCopyMemorySized +{ + OpCopyMemorySized(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->target = Id::fromWord(it.word(1)); + this->source = Id::fromWord(it.word(2)); + this->size = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->memoryAccess0 = DecodeParam(it, word); + this->memoryAccess1 = DecodeParam(it, word); + } + OpCopyMemorySized(Id target, Id source, Id size, MemoryAccessAndParamDatas memoryAccess0 = MemoryAccess::None, MemoryAccessAndParamDatas memoryAccess1 = MemoryAccess::None) + : op(Op::CopyMemorySized) + , wordCount(MinWordSize + ExtraWordCount(memoryAccess0) + ExtraWordCount(memoryAccess1)) + { + this->target = target; + this->source = source; + this->size = size; + this->memoryAccess0 = memoryAccess0; + this->memoryAccess1 = memoryAccess1; + } + operator Operation() const + { + std::vector words; + words.push_back(target.value()); + words.push_back(source.value()); + words.push_back(size.value()); + EncodeParam(words, memoryAccess0); + EncodeParam(words, memoryAccess1); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CopyMemorySized; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id target; + Id source; + Id size; + MemoryAccessAndParamDatas memoryAccess0; + MemoryAccessAndParamDatas memoryAccess1; +}; + +struct OpAccessChain +{ + OpAccessChain(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->base = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->indexes = MultiParam(it, word); + } + OpAccessChain(IdResultType resultType, IdResult result, Id base, const rdcarray &indexes = {}) + : op(Op::AccessChain) + , wordCount(MinWordSize + MultiWordCount(indexes)) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->indexes = indexes; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(base.value()); + for(size_t i=0; i < indexes.size(); i++) + { + words.push_back(indexes[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::AccessChain; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + rdcarray indexes; +}; + +struct OpInBoundsAccessChain +{ + OpInBoundsAccessChain(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->base = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->indexes = MultiParam(it, word); + } + OpInBoundsAccessChain(IdResultType resultType, IdResult result, Id base, const rdcarray &indexes = {}) + : op(Op::InBoundsAccessChain) + , wordCount(MinWordSize + MultiWordCount(indexes)) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->indexes = indexes; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(base.value()); + for(size_t i=0; i < indexes.size(); i++) + { + words.push_back(indexes[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::InBoundsAccessChain; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + rdcarray indexes; +}; + +struct OpPtrAccessChain +{ + OpPtrAccessChain(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->base = Id::fromWord(it.word(3)); + this->element = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->indexes = MultiParam(it, word); + } + OpPtrAccessChain(IdResultType resultType, IdResult result, Id base, Id element, const rdcarray &indexes = {}) + : op(Op::PtrAccessChain) + , wordCount(MinWordSize + MultiWordCount(indexes)) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->element = element; + this->indexes = indexes; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(base.value()); + words.push_back(element.value()); + for(size_t i=0; i < indexes.size(); i++) + { + words.push_back(indexes[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::PtrAccessChain; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id element; + rdcarray indexes; +}; + +struct OpArrayLength +{ + OpArrayLength(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpArrayLength(IdResultType resultType, IdResult result, Id structure, uint32_t arraymember) + : op(Op::ArrayLength) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->structure = structure; + this->arraymember = arraymember; + } + + static constexpr Op OpCode = Op::ArrayLength; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id structure; + uint32_t arraymember; +}; + +struct OpGenericPtrMemSemantics +{ + OpGenericPtrMemSemantics(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGenericPtrMemSemantics(IdResultType resultType, IdResult result, Id pointer) + : op(Op::GenericPtrMemSemantics) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + } + + static constexpr Op OpCode = Op::GenericPtrMemSemantics; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; +}; + +struct OpInBoundsPtrAccessChain +{ + OpInBoundsPtrAccessChain(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->base = Id::fromWord(it.word(3)); + this->element = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->indexes = MultiParam(it, word); + } + OpInBoundsPtrAccessChain(IdResultType resultType, IdResult result, Id base, Id element, const rdcarray &indexes = {}) + : op(Op::InBoundsPtrAccessChain) + , wordCount(MinWordSize + MultiWordCount(indexes)) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->element = element; + this->indexes = indexes; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(base.value()); + words.push_back(element.value()); + for(size_t i=0; i < indexes.size(); i++) + { + words.push_back(indexes[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::InBoundsPtrAccessChain; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id element; + rdcarray indexes; +}; + +struct OpDecorate +{ + OpDecorate(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->target = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->decoration = DecodeParam(it, word); + } + OpDecorate(Id target, DecorationAndParamData decoration) + : op(Op::Decorate) + , wordCount(MinWordSize + ExtraWordCount(decoration)) + { + this->target = target; + this->decoration = decoration; + } + operator Operation() const + { + std::vector words; + words.push_back(target.value()); + EncodeParam(words, decoration); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Decorate; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id target; + DecorationAndParamData decoration; +}; + +struct OpMemberDecorate +{ + OpMemberDecorate(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->structureType = Id::fromWord(it.word(1)); + this->member = (uint32_t)it.word(2); + uint32_t word = 3; + this->decoration = DecodeParam(it, word); + } + OpMemberDecorate(Id structureType, uint32_t member, DecorationAndParamData decoration) + : op(Op::MemberDecorate) + , wordCount(MinWordSize + ExtraWordCount(decoration)) + { + this->structureType = structureType; + this->member = member; + this->decoration = decoration; + } + operator Operation() const + { + std::vector words; + words.push_back(structureType.value()); + words.push_back((uint32_t)member); + EncodeParam(words, decoration); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::MemberDecorate; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id structureType; + uint32_t member; + DecorationAndParamData decoration; +}; + +struct OpDecorationGroup +{ + OpDecorationGroup(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDecorationGroup(IdResult result) + : op(Op::DecorationGroup) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::DecorationGroup; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpGroupDecorate +{ + OpGroupDecorate(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->decorationGroup = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->targets = MultiParam(it, word); + } + OpGroupDecorate(Id decorationGroup, const rdcarray &targets = {}) + : op(Op::GroupDecorate) + , wordCount(MinWordSize + MultiWordCount(targets)) + { + this->decorationGroup = decorationGroup; + this->targets = targets; + } + operator Operation() const + { + std::vector words; + words.push_back(decorationGroup.value()); + for(size_t i=0; i < targets.size(); i++) + { + words.push_back(targets[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupDecorate; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + Id decorationGroup; + rdcarray targets; +}; + +struct OpGroupMemberDecorate +{ + OpGroupMemberDecorate(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->decorationGroup = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->targets = MultiParam(it, word); + } + OpGroupMemberDecorate(Id decorationGroup, const rdcarray &targets = {}) + : op(Op::GroupMemberDecorate) + , wordCount(MinWordSize + MultiWordCount(targets)) + { + this->decorationGroup = decorationGroup; + this->targets = targets; + } + operator Operation() const + { + std::vector words; + words.push_back(decorationGroup.value()); + for(size_t i=0; i < targets.size(); i++) + { + words.push_back(targets[i].first.value()); words.push_back((uint32_t)targets[i].second); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupMemberDecorate; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + Id decorationGroup; + rdcarray targets; +}; + +struct OpVectorExtractDynamic +{ + OpVectorExtractDynamic(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpVectorExtractDynamic(IdResultType resultType, IdResult result, Id vector, Id index) + : op(Op::VectorExtractDynamic) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector = vector; + this->index = index; + } + + static constexpr Op OpCode = Op::VectorExtractDynamic; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector; + Id index; +}; + +struct OpVectorInsertDynamic +{ + OpVectorInsertDynamic(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpVectorInsertDynamic(IdResultType resultType, IdResult result, Id vector, Id component, Id index) + : op(Op::VectorInsertDynamic) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector = vector; + this->component = component; + this->index = index; + } + + static constexpr Op OpCode = Op::VectorInsertDynamic; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector; + Id component; + Id index; +}; + +struct OpVectorShuffle +{ + OpVectorShuffle(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->vector1 = Id::fromWord(it.word(3)); + this->vector2 = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->components = MultiParam(it, word); + } + OpVectorShuffle(IdResultType resultType, IdResult result, Id vector1, Id vector2, const rdcarray &components = {}) + : op(Op::VectorShuffle) + , wordCount(MinWordSize + MultiWordCount(components)) + { + this->resultType = resultType; + this->result = result; + this->vector1 = vector1; + this->vector2 = vector2; + this->components = components; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(vector1.value()); + words.push_back(vector2.value()); + for(size_t i=0; i < components.size(); i++) + { + words.push_back((uint32_t)components[i]); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::VectorShuffle; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector1; + Id vector2; + rdcarray components; +}; + +struct OpCompositeConstruct +{ + OpCompositeConstruct(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->constituents = MultiParam(it, word); + } + OpCompositeConstruct(IdResultType resultType, IdResult result, const rdcarray &constituents = {}) + : op(Op::CompositeConstruct) + , wordCount(MinWordSize + MultiWordCount(constituents)) + { + this->resultType = resultType; + this->result = result; + this->constituents = constituents; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + for(size_t i=0; i < constituents.size(); i++) + { + words.push_back(constituents[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CompositeConstruct; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + rdcarray constituents; +}; + +struct OpCompositeExtract +{ + OpCompositeExtract(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->composite = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->indexes = MultiParam(it, word); + } + OpCompositeExtract(IdResultType resultType, IdResult result, Id composite, const rdcarray &indexes = {}) + : op(Op::CompositeExtract) + , wordCount(MinWordSize + MultiWordCount(indexes)) + { + this->resultType = resultType; + this->result = result; + this->composite = composite; + this->indexes = indexes; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(composite.value()); + for(size_t i=0; i < indexes.size(); i++) + { + words.push_back((uint32_t)indexes[i]); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CompositeExtract; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id composite; + rdcarray indexes; +}; + +struct OpCompositeInsert +{ + OpCompositeInsert(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->object = Id::fromWord(it.word(3)); + this->composite = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->indexes = MultiParam(it, word); + } + OpCompositeInsert(IdResultType resultType, IdResult result, Id object, Id composite, const rdcarray &indexes = {}) + : op(Op::CompositeInsert) + , wordCount(MinWordSize + MultiWordCount(indexes)) + { + this->resultType = resultType; + this->result = result; + this->object = object; + this->composite = composite; + this->indexes = indexes; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(object.value()); + words.push_back(composite.value()); + for(size_t i=0; i < indexes.size(); i++) + { + words.push_back((uint32_t)indexes[i]); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CompositeInsert; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id object; + Id composite; + rdcarray indexes; +}; + +struct OpCopyObject +{ + OpCopyObject(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCopyObject(IdResultType resultType, IdResult result, Id operand) + : op(Op::CopyObject) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::CopyObject; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpTranspose +{ + OpTranspose(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTranspose(IdResultType resultType, IdResult result, Id matrix) + : op(Op::Transpose) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->matrix = matrix; + } + + static constexpr Op OpCode = Op::Transpose; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id matrix; +}; + +struct OpSampledImage +{ + OpSampledImage(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSampledImage(IdResultType resultType, IdResult result, Id image, Id sampler) + : op(Op::SampledImage) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->sampler = sampler; + } + + static constexpr Op OpCode = Op::SampledImage; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id sampler; +}; + +struct OpImageSampleImplicitLod +{ + OpImageSampleImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSampleImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleImplicitLod; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleExplicitLod +{ + OpImageSampleExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSampleExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleExplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleDrefImplicitLod +{ + OpImageSampleDrefImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleDrefImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSampleDrefImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleDrefImplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleDrefExplicitLod +{ + OpImageSampleDrefExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleDrefExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSampleDrefExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleDrefExplicitLod; + static constexpr uint16_t MinWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleProjImplicitLod +{ + OpImageSampleProjImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleProjImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSampleProjImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleProjImplicitLod; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleProjExplicitLod +{ + OpImageSampleProjExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleProjExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSampleProjExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleProjExplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleProjDrefImplicitLod +{ + OpImageSampleProjDrefImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleProjDrefImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSampleProjDrefImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleProjDrefImplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSampleProjDrefExplicitLod +{ + OpImageSampleProjDrefExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleProjDrefExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSampleProjDrefExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleProjDrefExplicitLod; + static constexpr uint16_t MinWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageFetch +{ + OpImageFetch(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->image = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageFetch(IdResultType resultType, IdResult result, Id image, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageFetch) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(image.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageFetch; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageGather +{ + OpImageGather(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->component = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageGather(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id component, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageGather) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->component = component; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(component.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageGather; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id component; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageDrefGather +{ + OpImageDrefGather(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageDrefGather(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageDrefGather) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageDrefGather; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageRead +{ + OpImageRead(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->image = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageRead(IdResultType resultType, IdResult result, Id image, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageRead) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(image.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageRead; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageWrite +{ + OpImageWrite(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->image = Id::fromWord(it.word(1)); + this->coordinate = Id::fromWord(it.word(2)); + this->texel = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->imageOperands = DecodeParam(it, word); + } + OpImageWrite(Id image, Id coordinate, Id texel, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageWrite) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->image = image; + this->coordinate = coordinate; + this->texel = texel; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(image.value()); + words.push_back(coordinate.value()); + words.push_back(texel.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageWrite; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id image; + Id coordinate; + Id texel; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImage +{ + OpImage(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImage(IdResultType resultType, IdResult result, Id sampledImage) + : op(Op::Image) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + } + + static constexpr Op OpCode = Op::Image; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; +}; + +struct OpImageQueryFormat +{ + OpImageQueryFormat(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQueryFormat(IdResultType resultType, IdResult result, Id image) + : op(Op::ImageQueryFormat) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + } + + static constexpr Op OpCode = Op::ImageQueryFormat; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; +}; + +struct OpImageQueryOrder +{ + OpImageQueryOrder(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQueryOrder(IdResultType resultType, IdResult result, Id image) + : op(Op::ImageQueryOrder) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + } + + static constexpr Op OpCode = Op::ImageQueryOrder; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; +}; + +struct OpImageQuerySizeLod +{ + OpImageQuerySizeLod(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQuerySizeLod(IdResultType resultType, IdResult result, Id image, Id levelofDetail) + : op(Op::ImageQuerySizeLod) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->levelofDetail = levelofDetail; + } + + static constexpr Op OpCode = Op::ImageQuerySizeLod; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id levelofDetail; +}; + +struct OpImageQuerySize +{ + OpImageQuerySize(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQuerySize(IdResultType resultType, IdResult result, Id image) + : op(Op::ImageQuerySize) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + } + + static constexpr Op OpCode = Op::ImageQuerySize; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; +}; + +struct OpImageQueryLod +{ + OpImageQueryLod(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQueryLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate) + : op(Op::ImageQueryLod) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + } + + static constexpr Op OpCode = Op::ImageQueryLod; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; +}; + +struct OpImageQueryLevels +{ + OpImageQueryLevels(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQueryLevels(IdResultType resultType, IdResult result, Id image) + : op(Op::ImageQueryLevels) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + } + + static constexpr Op OpCode = Op::ImageQueryLevels; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; +}; + +struct OpImageQuerySamples +{ + OpImageQuerySamples(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageQuerySamples(IdResultType resultType, IdResult result, Id image) + : op(Op::ImageQuerySamples) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + } + + static constexpr Op OpCode = Op::ImageQuerySamples; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; +}; + +struct OpConvertFToU +{ + OpConvertFToU(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConvertFToU(IdResultType resultType, IdResult result, Id floatValue) + : op(Op::ConvertFToU) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->floatValue = floatValue; + } + + static constexpr Op OpCode = Op::ConvertFToU; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id floatValue; +}; + +struct OpConvertFToS +{ + OpConvertFToS(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConvertFToS(IdResultType resultType, IdResult result, Id floatValue) + : op(Op::ConvertFToS) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->floatValue = floatValue; + } + + static constexpr Op OpCode = Op::ConvertFToS; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id floatValue; +}; + +struct OpConvertSToF +{ + OpConvertSToF(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConvertSToF(IdResultType resultType, IdResult result, Id signedValue) + : op(Op::ConvertSToF) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->signedValue = signedValue; + } + + static constexpr Op OpCode = Op::ConvertSToF; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id signedValue; +}; + +struct OpConvertUToF +{ + OpConvertUToF(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConvertUToF(IdResultType resultType, IdResult result, Id unsignedValue) + : op(Op::ConvertUToF) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->unsignedValue = unsignedValue; + } + + static constexpr Op OpCode = Op::ConvertUToF; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id unsignedValue; +}; + +struct OpUConvert +{ + OpUConvert(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUConvert(IdResultType resultType, IdResult result, Id unsignedValue) + : op(Op::UConvert) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->unsignedValue = unsignedValue; + } + + static constexpr Op OpCode = Op::UConvert; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id unsignedValue; +}; + +struct OpSConvert +{ + OpSConvert(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSConvert(IdResultType resultType, IdResult result, Id signedValue) + : op(Op::SConvert) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->signedValue = signedValue; + } + + static constexpr Op OpCode = Op::SConvert; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id signedValue; +}; + +struct OpFConvert +{ + OpFConvert(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFConvert(IdResultType resultType, IdResult result, Id floatValue) + : op(Op::FConvert) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->floatValue = floatValue; + } + + static constexpr Op OpCode = Op::FConvert; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id floatValue; +}; + +struct OpQuantizeToF16 +{ + OpQuantizeToF16(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpQuantizeToF16(IdResultType resultType, IdResult result, Id value) + : op(Op::QuantizeToF16) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->value = value; + } + + static constexpr Op OpCode = Op::QuantizeToF16; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id value; +}; + +struct OpConvertPtrToU +{ + OpConvertPtrToU(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConvertPtrToU(IdResultType resultType, IdResult result, Id pointer) + : op(Op::ConvertPtrToU) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + } + + static constexpr Op OpCode = Op::ConvertPtrToU; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; +}; + +struct OpSatConvertSToU +{ + OpSatConvertSToU(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSatConvertSToU(IdResultType resultType, IdResult result, Id signedValue) + : op(Op::SatConvertSToU) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->signedValue = signedValue; + } + + static constexpr Op OpCode = Op::SatConvertSToU; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id signedValue; +}; + +struct OpSatConvertUToS +{ + OpSatConvertUToS(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSatConvertUToS(IdResultType resultType, IdResult result, Id unsignedValue) + : op(Op::SatConvertUToS) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->unsignedValue = unsignedValue; + } + + static constexpr Op OpCode = Op::SatConvertUToS; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id unsignedValue; +}; + +struct OpConvertUToPtr +{ + OpConvertUToPtr(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConvertUToPtr(IdResultType resultType, IdResult result, Id integerValue) + : op(Op::ConvertUToPtr) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->integerValue = integerValue; + } + + static constexpr Op OpCode = Op::ConvertUToPtr; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id integerValue; +}; + +struct OpPtrCastToGeneric +{ + OpPtrCastToGeneric(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpPtrCastToGeneric(IdResultType resultType, IdResult result, Id pointer) + : op(Op::PtrCastToGeneric) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + } + + static constexpr Op OpCode = Op::PtrCastToGeneric; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; +}; + +struct OpGenericCastToPtr +{ + OpGenericCastToPtr(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGenericCastToPtr(IdResultType resultType, IdResult result, Id pointer) + : op(Op::GenericCastToPtr) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + } + + static constexpr Op OpCode = Op::GenericCastToPtr; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; +}; + +struct OpGenericCastToPtrExplicit +{ + OpGenericCastToPtrExplicit(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGenericCastToPtrExplicit(IdResultType resultType, IdResult result, Id pointer, StorageClass storage) + : op(Op::GenericCastToPtrExplicit) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->storage = storage; + } + + static constexpr Op OpCode = Op::GenericCastToPtrExplicit; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + StorageClass storage; +}; + +struct OpBitcast +{ + OpBitcast(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitcast(IdResultType resultType, IdResult result, Id operand) + : op(Op::Bitcast) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::Bitcast; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpSNegate +{ + OpSNegate(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSNegate(IdResultType resultType, IdResult result, Id operand) + : op(Op::SNegate) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::SNegate; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpFNegate +{ + OpFNegate(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFNegate(IdResultType resultType, IdResult result, Id operand) + : op(Op::FNegate) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::FNegate; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpIAdd +{ + OpIAdd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIAdd(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IAdd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IAdd; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFAdd +{ + OpFAdd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFAdd(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FAdd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FAdd; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpISub +{ + OpISub(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpISub(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::ISub) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::ISub; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFSub +{ + OpFSub(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFSub(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FSub) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FSub; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpIMul +{ + OpIMul(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIMul(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IMul) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IMul; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFMul +{ + OpFMul(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFMul(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FMul) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FMul; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUDiv +{ + OpUDiv(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUDiv(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UDiv) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UDiv; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSDiv +{ + OpSDiv(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSDiv(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SDiv) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SDiv; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFDiv +{ + OpFDiv(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFDiv(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FDiv) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FDiv; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUMod +{ + OpUMod(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUMod(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UMod) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UMod; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSRem +{ + OpSRem(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSRem(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SRem) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SRem; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSMod +{ + OpSMod(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSMod(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SMod) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SMod; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFRem +{ + OpFRem(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFRem(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FRem) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FRem; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFMod +{ + OpFMod(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFMod(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FMod) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FMod; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpVectorTimesScalar +{ + OpVectorTimesScalar(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpVectorTimesScalar(IdResultType resultType, IdResult result, Id vector, Id scalar) + : op(Op::VectorTimesScalar) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector = vector; + this->scalar = scalar; + } + + static constexpr Op OpCode = Op::VectorTimesScalar; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector; + Id scalar; +}; + +struct OpMatrixTimesScalar +{ + OpMatrixTimesScalar(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpMatrixTimesScalar(IdResultType resultType, IdResult result, Id matrix, Id scalar) + : op(Op::MatrixTimesScalar) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->matrix = matrix; + this->scalar = scalar; + } + + static constexpr Op OpCode = Op::MatrixTimesScalar; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id matrix; + Id scalar; +}; + +struct OpVectorTimesMatrix +{ + OpVectorTimesMatrix(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpVectorTimesMatrix(IdResultType resultType, IdResult result, Id vector, Id matrix) + : op(Op::VectorTimesMatrix) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector = vector; + this->matrix = matrix; + } + + static constexpr Op OpCode = Op::VectorTimesMatrix; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector; + Id matrix; +}; + +struct OpMatrixTimesVector +{ + OpMatrixTimesVector(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpMatrixTimesVector(IdResultType resultType, IdResult result, Id matrix, Id vector) + : op(Op::MatrixTimesVector) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->matrix = matrix; + this->vector = vector; + } + + static constexpr Op OpCode = Op::MatrixTimesVector; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id matrix; + Id vector; +}; + +struct OpMatrixTimesMatrix +{ + OpMatrixTimesMatrix(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpMatrixTimesMatrix(IdResultType resultType, IdResult result, Id leftMatrix, Id rightMatrix) + : op(Op::MatrixTimesMatrix) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->leftMatrix = leftMatrix; + this->rightMatrix = rightMatrix; + } + + static constexpr Op OpCode = Op::MatrixTimesMatrix; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id leftMatrix; + Id rightMatrix; +}; + +struct OpOuterProduct +{ + OpOuterProduct(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpOuterProduct(IdResultType resultType, IdResult result, Id vector1, Id vector2) + : op(Op::OuterProduct) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector1 = vector1; + this->vector2 = vector2; + } + + static constexpr Op OpCode = Op::OuterProduct; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector1; + Id vector2; +}; + +struct OpDot +{ + OpDot(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDot(IdResultType resultType, IdResult result, Id vector1, Id vector2) + : op(Op::Dot) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector1 = vector1; + this->vector2 = vector2; + } + + static constexpr Op OpCode = Op::Dot; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector1; + Id vector2; +}; + +struct OpIAddCarry +{ + OpIAddCarry(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIAddCarry(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IAddCarry) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IAddCarry; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpISubBorrow +{ + OpISubBorrow(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpISubBorrow(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::ISubBorrow) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::ISubBorrow; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUMulExtended +{ + OpUMulExtended(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUMulExtended(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UMulExtended) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UMulExtended; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSMulExtended +{ + OpSMulExtended(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSMulExtended(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SMulExtended) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SMulExtended; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpAny +{ + OpAny(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAny(IdResultType resultType, IdResult result, Id vector) + : op(Op::Any) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector = vector; + } + + static constexpr Op OpCode = Op::Any; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector; +}; + +struct OpAll +{ + OpAll(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAll(IdResultType resultType, IdResult result, Id vector) + : op(Op::All) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->vector = vector; + } + + static constexpr Op OpCode = Op::All; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id vector; +}; + +struct OpIsNan +{ + OpIsNan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsNan(IdResultType resultType, IdResult result, Id x) + : op(Op::IsNan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + } + + static constexpr Op OpCode = Op::IsNan; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; +}; + +struct OpIsInf +{ + OpIsInf(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsInf(IdResultType resultType, IdResult result, Id x) + : op(Op::IsInf) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + } + + static constexpr Op OpCode = Op::IsInf; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; +}; + +struct OpIsFinite +{ + OpIsFinite(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsFinite(IdResultType resultType, IdResult result, Id x) + : op(Op::IsFinite) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + } + + static constexpr Op OpCode = Op::IsFinite; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; +}; + +struct OpIsNormal +{ + OpIsNormal(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsNormal(IdResultType resultType, IdResult result, Id x) + : op(Op::IsNormal) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + } + + static constexpr Op OpCode = Op::IsNormal; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; +}; + +struct OpSignBitSet +{ + OpSignBitSet(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSignBitSet(IdResultType resultType, IdResult result, Id x) + : op(Op::SignBitSet) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + } + + static constexpr Op OpCode = Op::SignBitSet; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; +}; + +struct OpLessOrGreater +{ + OpLessOrGreater(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLessOrGreater(IdResultType resultType, IdResult result, Id x, Id y) + : op(Op::LessOrGreater) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + this->y = y; + } + + static constexpr Op OpCode = Op::LessOrGreater; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; + Id y; +}; + +struct OpOrdered +{ + OpOrdered(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpOrdered(IdResultType resultType, IdResult result, Id x, Id y) + : op(Op::Ordered) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + this->y = y; + } + + static constexpr Op OpCode = Op::Ordered; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; + Id y; +}; + +struct OpUnordered +{ + OpUnordered(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUnordered(IdResultType resultType, IdResult result, Id x, Id y) + : op(Op::Unordered) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->x = x; + this->y = y; + } + + static constexpr Op OpCode = Op::Unordered; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id x; + Id y; +}; + +struct OpLogicalEqual +{ + OpLogicalEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLogicalEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::LogicalEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::LogicalEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpLogicalNotEqual +{ + OpLogicalNotEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLogicalNotEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::LogicalNotEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::LogicalNotEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpLogicalOr +{ + OpLogicalOr(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLogicalOr(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::LogicalOr) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::LogicalOr; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpLogicalAnd +{ + OpLogicalAnd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLogicalAnd(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::LogicalAnd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::LogicalAnd; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpLogicalNot +{ + OpLogicalNot(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLogicalNot(IdResultType resultType, IdResult result, Id operand) + : op(Op::LogicalNot) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::LogicalNot; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpSelect +{ + OpSelect(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSelect(IdResultType resultType, IdResult result, Id condition, Id object1, Id object2) + : op(Op::Select) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->condition = condition; + this->object1 = object1; + this->object2 = object2; + } + + static constexpr Op OpCode = Op::Select; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id condition; + Id object1; + Id object2; +}; + +struct OpIEqual +{ + OpIEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpINotEqual +{ + OpINotEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpINotEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::INotEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::INotEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUGreaterThan +{ + OpUGreaterThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUGreaterThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UGreaterThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UGreaterThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSGreaterThan +{ + OpSGreaterThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSGreaterThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SGreaterThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SGreaterThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUGreaterThanEqual +{ + OpUGreaterThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUGreaterThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UGreaterThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UGreaterThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSGreaterThanEqual +{ + OpSGreaterThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSGreaterThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SGreaterThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SGreaterThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpULessThan +{ + OpULessThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpULessThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::ULessThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::ULessThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSLessThan +{ + OpSLessThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSLessThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SLessThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SLessThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpULessThanEqual +{ + OpULessThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpULessThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::ULessThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::ULessThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSLessThanEqual +{ + OpSLessThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSLessThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::SLessThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::SLessThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFOrdEqual +{ + OpFOrdEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFOrdEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FOrdEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FOrdEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFUnordEqual +{ + OpFUnordEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFUnordEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FUnordEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FUnordEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFOrdNotEqual +{ + OpFOrdNotEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFOrdNotEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FOrdNotEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FOrdNotEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFUnordNotEqual +{ + OpFUnordNotEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFUnordNotEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FUnordNotEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FUnordNotEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFOrdLessThan +{ + OpFOrdLessThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFOrdLessThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FOrdLessThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FOrdLessThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFUnordLessThan +{ + OpFUnordLessThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFUnordLessThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FUnordLessThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FUnordLessThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFOrdGreaterThan +{ + OpFOrdGreaterThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFOrdGreaterThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FOrdGreaterThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FOrdGreaterThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFUnordGreaterThan +{ + OpFUnordGreaterThan(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFUnordGreaterThan(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FUnordGreaterThan) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FUnordGreaterThan; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFOrdLessThanEqual +{ + OpFOrdLessThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFOrdLessThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FOrdLessThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FOrdLessThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFUnordLessThanEqual +{ + OpFUnordLessThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFUnordLessThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FUnordLessThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FUnordLessThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFOrdGreaterThanEqual +{ + OpFOrdGreaterThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFOrdGreaterThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FOrdGreaterThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FOrdGreaterThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpFUnordGreaterThanEqual +{ + OpFUnordGreaterThanEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFUnordGreaterThanEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::FUnordGreaterThanEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::FUnordGreaterThanEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpShiftRightLogical +{ + OpShiftRightLogical(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpShiftRightLogical(IdResultType resultType, IdResult result, Id base, Id shift) + : op(Op::ShiftRightLogical) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->shift = shift; + } + + static constexpr Op OpCode = Op::ShiftRightLogical; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id shift; +}; + +struct OpShiftRightArithmetic +{ + OpShiftRightArithmetic(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpShiftRightArithmetic(IdResultType resultType, IdResult result, Id base, Id shift) + : op(Op::ShiftRightArithmetic) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->shift = shift; + } + + static constexpr Op OpCode = Op::ShiftRightArithmetic; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id shift; +}; + +struct OpShiftLeftLogical +{ + OpShiftLeftLogical(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpShiftLeftLogical(IdResultType resultType, IdResult result, Id base, Id shift) + : op(Op::ShiftLeftLogical) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->shift = shift; + } + + static constexpr Op OpCode = Op::ShiftLeftLogical; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id shift; +}; + +struct OpBitwiseOr +{ + OpBitwiseOr(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitwiseOr(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::BitwiseOr) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::BitwiseOr; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpBitwiseXor +{ + OpBitwiseXor(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitwiseXor(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::BitwiseXor) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::BitwiseXor; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpBitwiseAnd +{ + OpBitwiseAnd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitwiseAnd(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::BitwiseAnd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::BitwiseAnd; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpNot +{ + OpNot(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpNot(IdResultType resultType, IdResult result, Id operand) + : op(Op::Not) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::Not; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpBitFieldInsert +{ + OpBitFieldInsert(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitFieldInsert(IdResultType resultType, IdResult result, Id base, Id insert, Id offset, Id count) + : op(Op::BitFieldInsert) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->insert = insert; + this->offset = offset; + this->count = count; + } + + static constexpr Op OpCode = Op::BitFieldInsert; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id insert; + Id offset; + Id count; +}; + +struct OpBitFieldSExtract +{ + OpBitFieldSExtract(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitFieldSExtract(IdResultType resultType, IdResult result, Id base, Id offset, Id count) + : op(Op::BitFieldSExtract) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->offset = offset; + this->count = count; + } + + static constexpr Op OpCode = Op::BitFieldSExtract; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id offset; + Id count; +}; + +struct OpBitFieldUExtract +{ + OpBitFieldUExtract(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitFieldUExtract(IdResultType resultType, IdResult result, Id base, Id offset, Id count) + : op(Op::BitFieldUExtract) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + this->offset = offset; + this->count = count; + } + + static constexpr Op OpCode = Op::BitFieldUExtract; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; + Id offset; + Id count; +}; + +struct OpBitReverse +{ + OpBitReverse(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitReverse(IdResultType resultType, IdResult result, Id base) + : op(Op::BitReverse) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + } + + static constexpr Op OpCode = Op::BitReverse; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; +}; + +struct OpBitCount +{ + OpBitCount(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBitCount(IdResultType resultType, IdResult result, Id base) + : op(Op::BitCount) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->base = base; + } + + static constexpr Op OpCode = Op::BitCount; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id base; +}; + +struct OpDPdx +{ + OpDPdx(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDPdx(IdResultType resultType, IdResult result, Id p) + : op(Op::DPdx) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::DPdx; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpDPdy +{ + OpDPdy(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDPdy(IdResultType resultType, IdResult result, Id p) + : op(Op::DPdy) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::DPdy; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpFwidth +{ + OpFwidth(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFwidth(IdResultType resultType, IdResult result, Id p) + : op(Op::Fwidth) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::Fwidth; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpDPdxFine +{ + OpDPdxFine(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDPdxFine(IdResultType resultType, IdResult result, Id p) + : op(Op::DPdxFine) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::DPdxFine; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpDPdyFine +{ + OpDPdyFine(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDPdyFine(IdResultType resultType, IdResult result, Id p) + : op(Op::DPdyFine) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::DPdyFine; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpFwidthFine +{ + OpFwidthFine(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFwidthFine(IdResultType resultType, IdResult result, Id p) + : op(Op::FwidthFine) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::FwidthFine; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpDPdxCoarse +{ + OpDPdxCoarse(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDPdxCoarse(IdResultType resultType, IdResult result, Id p) + : op(Op::DPdxCoarse) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::DPdxCoarse; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpDPdyCoarse +{ + OpDPdyCoarse(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDPdyCoarse(IdResultType resultType, IdResult result, Id p) + : op(Op::DPdyCoarse) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::DPdyCoarse; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpFwidthCoarse +{ + OpFwidthCoarse(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFwidthCoarse(IdResultType resultType, IdResult result, Id p) + : op(Op::FwidthCoarse) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->p = p; + } + + static constexpr Op OpCode = Op::FwidthCoarse; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id p; +}; + +struct OpEmitVertex +{ + OpEmitVertex(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpEmitVertex() + : op(Op::EmitVertex) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::EmitVertex; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpEndPrimitive +{ + OpEndPrimitive(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpEndPrimitive() + : op(Op::EndPrimitive) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::EndPrimitive; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpEmitStreamVertex +{ + OpEmitStreamVertex(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpEmitStreamVertex(Id stream) + : op(Op::EmitStreamVertex) + , wordCount(FixedWordSize) + { + this->stream = stream; + } + + static constexpr Op OpCode = Op::EmitStreamVertex; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Id stream; +}; + +struct OpEndStreamPrimitive +{ + OpEndStreamPrimitive(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpEndStreamPrimitive(Id stream) + : op(Op::EndStreamPrimitive) + , wordCount(FixedWordSize) + { + this->stream = stream; + } + + static constexpr Op OpCode = Op::EndStreamPrimitive; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Id stream; +}; + +struct OpControlBarrier +{ + OpControlBarrier(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpControlBarrier(IdScope execution, IdScope memory, IdMemorySemantics semantics) + : op(Op::ControlBarrier) + , wordCount(FixedWordSize) + { + this->execution = execution; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::ControlBarrier; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdScope execution; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpMemoryBarrier +{ + OpMemoryBarrier(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpMemoryBarrier(IdScope memory, IdMemorySemantics semantics) + : op(Op::MemoryBarrier) + , wordCount(FixedWordSize) + { + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::MemoryBarrier; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpAtomicLoad +{ + OpAtomicLoad(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicLoad(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics) + : op(Op::AtomicLoad) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::AtomicLoad; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpAtomicStore +{ + OpAtomicStore(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicStore(Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicStore) + , wordCount(FixedWordSize) + { + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicStore; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicExchange +{ + OpAtomicExchange(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicExchange(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicExchange) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicExchange; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicCompareExchange +{ + OpAtomicCompareExchange(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicCompareExchange(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics equal, IdMemorySemantics unequal, Id value, Id comparator) + : op(Op::AtomicCompareExchange) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->equal = equal; + this->unequal = unequal; + this->value = value; + this->comparator = comparator; + } + + static constexpr Op OpCode = Op::AtomicCompareExchange; + static constexpr uint16_t FixedWordSize = 9U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics equal; + IdMemorySemantics unequal; + Id value; + Id comparator; +}; + +struct OpAtomicCompareExchangeWeak +{ + OpAtomicCompareExchangeWeak(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicCompareExchangeWeak(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics equal, IdMemorySemantics unequal, Id value, Id comparator) + : op(Op::AtomicCompareExchangeWeak) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->equal = equal; + this->unequal = unequal; + this->value = value; + this->comparator = comparator; + } + + static constexpr Op OpCode = Op::AtomicCompareExchangeWeak; + static constexpr uint16_t FixedWordSize = 9U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics equal; + IdMemorySemantics unequal; + Id value; + Id comparator; +}; + +struct OpAtomicIIncrement +{ + OpAtomicIIncrement(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicIIncrement(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics) + : op(Op::AtomicIIncrement) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::AtomicIIncrement; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpAtomicIDecrement +{ + OpAtomicIDecrement(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicIDecrement(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics) + : op(Op::AtomicIDecrement) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::AtomicIDecrement; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpAtomicIAdd +{ + OpAtomicIAdd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicIAdd(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicIAdd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicIAdd; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicISub +{ + OpAtomicISub(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicISub(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicISub) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicISub; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicSMin +{ + OpAtomicSMin(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicSMin(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicSMin) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicSMin; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicUMin +{ + OpAtomicUMin(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicUMin(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicUMin) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicUMin; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicSMax +{ + OpAtomicSMax(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicSMax(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicSMax) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicSMax; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicUMax +{ + OpAtomicUMax(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicUMax(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicUMax) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicUMax; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicAnd +{ + OpAtomicAnd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicAnd(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicAnd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicAnd; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicOr +{ + OpAtomicOr(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicOr(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicOr) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicOr; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpAtomicXor +{ + OpAtomicXor(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicXor(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics, Id value) + : op(Op::AtomicXor) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + this->value = value; + } + + static constexpr Op OpCode = Op::AtomicXor; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; + Id value; +}; + +struct OpPhi +{ + OpPhi(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->parents = MultiParam(it, word); + } + OpPhi(IdResultType resultType, IdResult result, const rdcarray &parents = {}) + : op(Op::Phi) + , wordCount(MinWordSize + MultiWordCount(parents)) + { + this->resultType = resultType; + this->result = result; + this->parents = parents; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + for(size_t i=0; i < parents.size(); i++) + { + words.push_back(parents[i].first.value()); words.push_back(parents[i].second.value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Phi; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + rdcarray parents; +}; + +struct OpLoopMerge +{ + OpLoopMerge(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->mergeBlock = Id::fromWord(it.word(1)); + this->continueTarget = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->loopControl = DecodeParam(it, word); + } + OpLoopMerge(Id mergeBlock, Id continueTarget, LoopControlAndParamDatas loopControl) + : op(Op::LoopMerge) + , wordCount(MinWordSize + ExtraWordCount(loopControl)) + { + this->mergeBlock = mergeBlock; + this->continueTarget = continueTarget; + this->loopControl = loopControl; + } + operator Operation() const + { + std::vector words; + words.push_back(mergeBlock.value()); + words.push_back(continueTarget.value()); + EncodeParam(words, loopControl); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::LoopMerge; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id mergeBlock; + Id continueTarget; + LoopControlAndParamDatas loopControl; +}; + +struct OpSelectionMerge +{ + OpSelectionMerge(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSelectionMerge(Id mergeBlock, SelectionControl selectionControl) + : op(Op::SelectionMerge) + , wordCount(FixedWordSize) + { + this->mergeBlock = mergeBlock; + this->selectionControl = selectionControl; + } + + static constexpr Op OpCode = Op::SelectionMerge; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id mergeBlock; + SelectionControl selectionControl; +}; + +struct OpLabel +{ + OpLabel(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLabel(IdResult result) + : op(Op::Label) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::Label; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpBranch +{ + OpBranch(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBranch(Id targetLabel) + : op(Op::Branch) + , wordCount(FixedWordSize) + { + this->targetLabel = targetLabel; + } + + static constexpr Op OpCode = Op::Branch; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Id targetLabel; +}; + +struct OpBranchConditional +{ + OpBranchConditional(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->condition = Id::fromWord(it.word(1)); + this->trueLabel = Id::fromWord(it.word(2)); + this->falseLabel = Id::fromWord(it.word(3)); + uint32_t word = 4; + this->branchweights = MultiParam(it, word); + } + OpBranchConditional(Id condition, Id trueLabel, Id falseLabel, const rdcarray &branchweights = {}) + : op(Op::BranchConditional) + , wordCount(MinWordSize + MultiWordCount(branchweights)) + { + this->condition = condition; + this->trueLabel = trueLabel; + this->falseLabel = falseLabel; + this->branchweights = branchweights; + } + operator Operation() const + { + std::vector words; + words.push_back(condition.value()); + words.push_back(trueLabel.value()); + words.push_back(falseLabel.value()); + for(size_t i=0; i < branchweights.size(); i++) + { + words.push_back((uint32_t)branchweights[i]); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::BranchConditional; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id condition; + Id trueLabel; + Id falseLabel; + rdcarray branchweights; +}; + +struct OpSwitch +{ + OpSwitch(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->selector = Id::fromWord(it.word(1)); + this->def = Id::fromWord(it.word(2)); + uint32_t word = 3; + this->target = MultiParam(it, word); + } + OpSwitch(Id selector, Id def, const rdcarray &target = {}) + : op(Op::Switch) + , wordCount(MinWordSize + MultiWordCount(target)) + { + this->selector = selector; + this->def = def; + this->target = target; + } + operator Operation() const + { + std::vector words; + words.push_back(selector.value()); + words.push_back(def.value()); + for(size_t i=0; i < target.size(); i++) + { + words.push_back((uint32_t)target[i].first); words.push_back(target[i].second.value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::Switch; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id selector; + Id def; + rdcarray target; +}; + +struct OpKill +{ + OpKill(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpKill() + : op(Op::Kill) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::Kill; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpReturn +{ + OpReturn(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReturn() + : op(Op::Return) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::Return; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpReturnValue +{ + OpReturnValue(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReturnValue(Id value) + : op(Op::ReturnValue) + , wordCount(FixedWordSize) + { + this->value = value; + } + + static constexpr Op OpCode = Op::ReturnValue; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Id value; +}; + +struct OpUnreachable +{ + OpUnreachable(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUnreachable() + : op(Op::Unreachable) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::Unreachable; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpLifetimeStart +{ + OpLifetimeStart(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLifetimeStart(Id pointer, uint32_t size) + : op(Op::LifetimeStart) + , wordCount(FixedWordSize) + { + this->pointer = pointer; + this->size = size; + } + + static constexpr Op OpCode = Op::LifetimeStart; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id pointer; + uint32_t size; +}; + +struct OpLifetimeStop +{ + OpLifetimeStop(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpLifetimeStop(Id pointer, uint32_t size) + : op(Op::LifetimeStop) + , wordCount(FixedWordSize) + { + this->pointer = pointer; + this->size = size; + } + + static constexpr Op OpCode = Op::LifetimeStop; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id pointer; + uint32_t size; +}; + +struct OpGroupAsyncCopy +{ + OpGroupAsyncCopy(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupAsyncCopy(IdResultType resultType, IdResult result, IdScope execution, Id destination, Id source, Id numElements, Id stride, Id event) + : op(Op::GroupAsyncCopy) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->destination = destination; + this->source = source; + this->numElements = numElements; + this->stride = stride; + this->event = event; + } + + static constexpr Op OpCode = Op::GroupAsyncCopy; + static constexpr uint16_t FixedWordSize = 9U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id destination; + Id source; + Id numElements; + Id stride; + Id event; +}; + +struct OpGroupWaitEvents +{ + OpGroupWaitEvents(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupWaitEvents(IdScope execution, Id numEvents, Id eventsList) + : op(Op::GroupWaitEvents) + , wordCount(FixedWordSize) + { + this->execution = execution; + this->numEvents = numEvents; + this->eventsList = eventsList; + } + + static constexpr Op OpCode = Op::GroupWaitEvents; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdScope execution; + Id numEvents; + Id eventsList; +}; + +struct OpGroupAll +{ + OpGroupAll(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupAll(IdResultType resultType, IdResult result, IdScope execution, Id predicate) + : op(Op::GroupAll) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::GroupAll; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id predicate; +}; + +struct OpGroupAny +{ + OpGroupAny(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupAny(IdResultType resultType, IdResult result, IdScope execution, Id predicate) + : op(Op::GroupAny) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::GroupAny; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id predicate; +}; + +struct OpGroupBroadcast +{ + OpGroupBroadcast(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupBroadcast(IdResultType resultType, IdResult result, IdScope execution, Id value, Id localId) + : op(Op::GroupBroadcast) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->localId = localId; + } + + static constexpr Op OpCode = Op::GroupBroadcast; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id localId; +}; + +struct OpGroupIAdd +{ + OpGroupIAdd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupIAdd(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupIAdd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupIAdd; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupFAdd +{ + OpGroupFAdd(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupFAdd(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupFAdd) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupFAdd; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupFMin +{ + OpGroupFMin(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupFMin(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupFMin) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupFMin; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupUMin +{ + OpGroupUMin(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupUMin(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupUMin) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupUMin; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupSMin +{ + OpGroupSMin(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupSMin(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupSMin) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupSMin; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupFMax +{ + OpGroupFMax(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupFMax(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupFMax) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupFMax; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupUMax +{ + OpGroupUMax(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupUMax(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupUMax) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupUMax; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupSMax +{ + OpGroupSMax(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupSMax(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupSMax) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupSMax; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpReadPipe +{ + OpReadPipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReadPipe(IdResultType resultType, IdResult result, Id pipe, Id pointer, Id packetSize, Id packetAlignment) + : op(Op::ReadPipe) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->pointer = pointer; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::ReadPipe; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id pointer; + Id packetSize; + Id packetAlignment; +}; + +struct OpWritePipe +{ + OpWritePipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpWritePipe(IdResultType resultType, IdResult result, Id pipe, Id pointer, Id packetSize, Id packetAlignment) + : op(Op::WritePipe) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->pointer = pointer; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::WritePipe; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id pointer; + Id packetSize; + Id packetAlignment; +}; + +struct OpReservedReadPipe +{ + OpReservedReadPipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReservedReadPipe(IdResultType resultType, IdResult result, Id pipe, Id reserveId, Id index, Id pointer, Id packetSize, Id packetAlignment) + : op(Op::ReservedReadPipe) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->reserveId = reserveId; + this->index = index; + this->pointer = pointer; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::ReservedReadPipe; + static constexpr uint16_t FixedWordSize = 9U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id reserveId; + Id index; + Id pointer; + Id packetSize; + Id packetAlignment; +}; + +struct OpReservedWritePipe +{ + OpReservedWritePipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReservedWritePipe(IdResultType resultType, IdResult result, Id pipe, Id reserveId, Id index, Id pointer, Id packetSize, Id packetAlignment) + : op(Op::ReservedWritePipe) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->reserveId = reserveId; + this->index = index; + this->pointer = pointer; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::ReservedWritePipe; + static constexpr uint16_t FixedWordSize = 9U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id reserveId; + Id index; + Id pointer; + Id packetSize; + Id packetAlignment; +}; + +struct OpReserveReadPipePackets +{ + OpReserveReadPipePackets(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReserveReadPipePackets(IdResultType resultType, IdResult result, Id pipe, Id numPackets, Id packetSize, Id packetAlignment) + : op(Op::ReserveReadPipePackets) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->numPackets = numPackets; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::ReserveReadPipePackets; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id numPackets; + Id packetSize; + Id packetAlignment; +}; + +struct OpReserveWritePipePackets +{ + OpReserveWritePipePackets(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReserveWritePipePackets(IdResultType resultType, IdResult result, Id pipe, Id numPackets, Id packetSize, Id packetAlignment) + : op(Op::ReserveWritePipePackets) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->numPackets = numPackets; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::ReserveWritePipePackets; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id numPackets; + Id packetSize; + Id packetAlignment; +}; + +struct OpCommitReadPipe +{ + OpCommitReadPipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCommitReadPipe(Id pipe, Id reserveId, Id packetSize, Id packetAlignment) + : op(Op::CommitReadPipe) + , wordCount(FixedWordSize) + { + this->pipe = pipe; + this->reserveId = reserveId; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::CommitReadPipe; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + Id pipe; + Id reserveId; + Id packetSize; + Id packetAlignment; +}; + +struct OpCommitWritePipe +{ + OpCommitWritePipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCommitWritePipe(Id pipe, Id reserveId, Id packetSize, Id packetAlignment) + : op(Op::CommitWritePipe) + , wordCount(FixedWordSize) + { + this->pipe = pipe; + this->reserveId = reserveId; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::CommitWritePipe; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + Id pipe; + Id reserveId; + Id packetSize; + Id packetAlignment; +}; + +struct OpIsValidReserveId +{ + OpIsValidReserveId(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsValidReserveId(IdResultType resultType, IdResult result, Id reserveId) + : op(Op::IsValidReserveId) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->reserveId = reserveId; + } + + static constexpr Op OpCode = Op::IsValidReserveId; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id reserveId; +}; + +struct OpGetNumPipePackets +{ + OpGetNumPipePackets(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetNumPipePackets(IdResultType resultType, IdResult result, Id pipe, Id packetSize, Id packetAlignment) + : op(Op::GetNumPipePackets) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::GetNumPipePackets; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id packetSize; + Id packetAlignment; +}; + +struct OpGetMaxPipePackets +{ + OpGetMaxPipePackets(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetMaxPipePackets(IdResultType resultType, IdResult result, Id pipe, Id packetSize, Id packetAlignment) + : op(Op::GetMaxPipePackets) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipe = pipe; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::GetMaxPipePackets; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipe; + Id packetSize; + Id packetAlignment; +}; + +struct OpGroupReserveReadPipePackets +{ + OpGroupReserveReadPipePackets(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupReserveReadPipePackets(IdResultType resultType, IdResult result, IdScope execution, Id pipe, Id numPackets, Id packetSize, Id packetAlignment) + : op(Op::GroupReserveReadPipePackets) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->pipe = pipe; + this->numPackets = numPackets; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::GroupReserveReadPipePackets; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id pipe; + Id numPackets; + Id packetSize; + Id packetAlignment; +}; + +struct OpGroupReserveWritePipePackets +{ + OpGroupReserveWritePipePackets(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupReserveWritePipePackets(IdResultType resultType, IdResult result, IdScope execution, Id pipe, Id numPackets, Id packetSize, Id packetAlignment) + : op(Op::GroupReserveWritePipePackets) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->pipe = pipe; + this->numPackets = numPackets; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::GroupReserveWritePipePackets; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id pipe; + Id numPackets; + Id packetSize; + Id packetAlignment; +}; + +struct OpGroupCommitReadPipe +{ + OpGroupCommitReadPipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupCommitReadPipe(IdScope execution, Id pipe, Id reserveId, Id packetSize, Id packetAlignment) + : op(Op::GroupCommitReadPipe) + , wordCount(FixedWordSize) + { + this->execution = execution; + this->pipe = pipe; + this->reserveId = reserveId; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::GroupCommitReadPipe; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdScope execution; + Id pipe; + Id reserveId; + Id packetSize; + Id packetAlignment; +}; + +struct OpGroupCommitWritePipe +{ + OpGroupCommitWritePipe(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupCommitWritePipe(IdScope execution, Id pipe, Id reserveId, Id packetSize, Id packetAlignment) + : op(Op::GroupCommitWritePipe) + , wordCount(FixedWordSize) + { + this->execution = execution; + this->pipe = pipe; + this->reserveId = reserveId; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + } + + static constexpr Op OpCode = Op::GroupCommitWritePipe; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdScope execution; + Id pipe; + Id reserveId; + Id packetSize; + Id packetAlignment; +}; + +struct OpEnqueueMarker +{ + OpEnqueueMarker(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpEnqueueMarker(IdResultType resultType, IdResult result, Id queue, Id numEvents, Id waitEvents, Id retEvent) + : op(Op::EnqueueMarker) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->queue = queue; + this->numEvents = numEvents; + this->waitEvents = waitEvents; + this->retEvent = retEvent; + } + + static constexpr Op OpCode = Op::EnqueueMarker; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id queue; + Id numEvents; + Id waitEvents; + Id retEvent; +}; + +struct OpEnqueueKernel +{ + OpEnqueueKernel(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->queue = Id::fromWord(it.word(3)); + this->flags = Id::fromWord(it.word(4)); + this->nDRange = Id::fromWord(it.word(5)); + this->numEvents = Id::fromWord(it.word(6)); + this->waitEvents = Id::fromWord(it.word(7)); + this->retEvent = Id::fromWord(it.word(8)); + this->invoke = Id::fromWord(it.word(9)); + this->param = Id::fromWord(it.word(10)); + this->paramSize = Id::fromWord(it.word(11)); + this->paramAlign = Id::fromWord(it.word(12)); + uint32_t word = 13; + this->localSize = MultiParam(it, word); + } + OpEnqueueKernel(IdResultType resultType, IdResult result, Id queue, Id flags, Id nDRange, Id numEvents, Id waitEvents, Id retEvent, Id invoke, Id param, Id paramSize, Id paramAlign, const rdcarray &localSize = {}) + : op(Op::EnqueueKernel) + , wordCount(MinWordSize + MultiWordCount(localSize)) + { + this->resultType = resultType; + this->result = result; + this->queue = queue; + this->flags = flags; + this->nDRange = nDRange; + this->numEvents = numEvents; + this->waitEvents = waitEvents; + this->retEvent = retEvent; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + this->localSize = localSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(queue.value()); + words.push_back(flags.value()); + words.push_back(nDRange.value()); + words.push_back(numEvents.value()); + words.push_back(waitEvents.value()); + words.push_back(retEvent.value()); + words.push_back(invoke.value()); + words.push_back(param.value()); + words.push_back(paramSize.value()); + words.push_back(paramAlign.value()); + for(size_t i=0; i < localSize.size(); i++) + { + words.push_back(localSize[i].value()); + } + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::EnqueueKernel; + static constexpr uint16_t MinWordSize = 13U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id queue; + Id flags; + Id nDRange; + Id numEvents; + Id waitEvents; + Id retEvent; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; + rdcarray localSize; +}; + +struct OpGetKernelNDrangeSubGroupCount +{ + OpGetKernelNDrangeSubGroupCount(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetKernelNDrangeSubGroupCount(IdResultType resultType, IdResult result, Id nDRange, Id invoke, Id param, Id paramSize, Id paramAlign) + : op(Op::GetKernelNDrangeSubGroupCount) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->nDRange = nDRange; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + } + + static constexpr Op OpCode = Op::GetKernelNDrangeSubGroupCount; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id nDRange; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; +}; + +struct OpGetKernelNDrangeMaxSubGroupSize +{ + OpGetKernelNDrangeMaxSubGroupSize(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetKernelNDrangeMaxSubGroupSize(IdResultType resultType, IdResult result, Id nDRange, Id invoke, Id param, Id paramSize, Id paramAlign) + : op(Op::GetKernelNDrangeMaxSubGroupSize) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->nDRange = nDRange; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + } + + static constexpr Op OpCode = Op::GetKernelNDrangeMaxSubGroupSize; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id nDRange; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; +}; + +struct OpGetKernelWorkGroupSize +{ + OpGetKernelWorkGroupSize(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetKernelWorkGroupSize(IdResultType resultType, IdResult result, Id invoke, Id param, Id paramSize, Id paramAlign) + : op(Op::GetKernelWorkGroupSize) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + } + + static constexpr Op OpCode = Op::GetKernelWorkGroupSize; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; +}; + +struct OpGetKernelPreferredWorkGroupSizeMultiple +{ + OpGetKernelPreferredWorkGroupSizeMultiple(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetKernelPreferredWorkGroupSizeMultiple(IdResultType resultType, IdResult result, Id invoke, Id param, Id paramSize, Id paramAlign) + : op(Op::GetKernelPreferredWorkGroupSizeMultiple) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + } + + static constexpr Op OpCode = Op::GetKernelPreferredWorkGroupSizeMultiple; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; +}; + +struct OpRetainEvent +{ + OpRetainEvent(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpRetainEvent(Id event) + : op(Op::RetainEvent) + , wordCount(FixedWordSize) + { + this->event = event; + } + + static constexpr Op OpCode = Op::RetainEvent; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Id event; +}; + +struct OpReleaseEvent +{ + OpReleaseEvent(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReleaseEvent(Id event) + : op(Op::ReleaseEvent) + , wordCount(FixedWordSize) + { + this->event = event; + } + + static constexpr Op OpCode = Op::ReleaseEvent; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + Id event; +}; + +struct OpCreateUserEvent +{ + OpCreateUserEvent(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCreateUserEvent(IdResultType resultType, IdResult result) + : op(Op::CreateUserEvent) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::CreateUserEvent; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpIsValidEvent +{ + OpIsValidEvent(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsValidEvent(IdResultType resultType, IdResult result, Id event) + : op(Op::IsValidEvent) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->event = event; + } + + static constexpr Op OpCode = Op::IsValidEvent; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id event; +}; + +struct OpSetUserEventStatus +{ + OpSetUserEventStatus(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSetUserEventStatus(Id event, Id status) + : op(Op::SetUserEventStatus) + , wordCount(FixedWordSize) + { + this->event = event; + this->status = status; + } + + static constexpr Op OpCode = Op::SetUserEventStatus; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id event; + Id status; +}; + +struct OpCaptureEventProfilingInfo +{ + OpCaptureEventProfilingInfo(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCaptureEventProfilingInfo(Id event, Id profilingInfo, Id value) + : op(Op::CaptureEventProfilingInfo) + , wordCount(FixedWordSize) + { + this->event = event; + this->profilingInfo = profilingInfo; + this->value = value; + } + + static constexpr Op OpCode = Op::CaptureEventProfilingInfo; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + Id event; + Id profilingInfo; + Id value; +}; + +struct OpGetDefaultQueue +{ + OpGetDefaultQueue(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetDefaultQueue(IdResultType resultType, IdResult result) + : op(Op::GetDefaultQueue) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::GetDefaultQueue; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpBuildNDRange +{ + OpBuildNDRange(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBuildNDRange(IdResultType resultType, IdResult result, Id globalWorkSize, Id localWorkSize, Id globalWorkOffset) + : op(Op::BuildNDRange) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->globalWorkSize = globalWorkSize; + this->localWorkSize = localWorkSize; + this->globalWorkOffset = globalWorkOffset; + } + + static constexpr Op OpCode = Op::BuildNDRange; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id globalWorkSize; + Id localWorkSize; + Id globalWorkOffset; +}; + +struct OpImageSparseSampleImplicitLod +{ + OpImageSparseSampleImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseSampleImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleImplicitLod; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleExplicitLod +{ + OpImageSparseSampleExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSparseSampleExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleExplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleDrefImplicitLod +{ + OpImageSparseSampleDrefImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleDrefImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseSampleDrefImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleDrefImplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleDrefExplicitLod +{ + OpImageSparseSampleDrefExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleDrefExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSparseSampleDrefExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleDrefExplicitLod; + static constexpr uint16_t MinWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleProjImplicitLod +{ + OpImageSparseSampleProjImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleProjImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseSampleProjImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleProjImplicitLod; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleProjExplicitLod +{ + OpImageSparseSampleProjExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleProjExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSparseSampleProjExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleProjExplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleProjDrefImplicitLod +{ + OpImageSparseSampleProjDrefImplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleProjDrefImplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseSampleProjDrefImplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleProjDrefImplicitLod; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseSampleProjDrefExplicitLod +{ + OpImageSparseSampleProjDrefExplicitLod(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseSampleProjDrefExplicitLod(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands) + : op(Op::ImageSparseSampleProjDrefExplicitLod) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseSampleProjDrefExplicitLod; + static constexpr uint16_t MinWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseFetch +{ + OpImageSparseFetch(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->image = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseFetch(IdResultType resultType, IdResult result, Id image, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseFetch) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(image.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseFetch; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseGather +{ + OpImageSparseGather(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->component = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseGather(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id component, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseGather) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->component = component; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(component.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseGather; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id component; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseDrefGather +{ + OpImageSparseDrefGather(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->dref = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseDrefGather(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id dref, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseDrefGather) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->dref = dref; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(dref.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseDrefGather; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id dref; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpImageSparseTexelsResident +{ + OpImageSparseTexelsResident(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpImageSparseTexelsResident(IdResultType resultType, IdResult result, Id residentCode) + : op(Op::ImageSparseTexelsResident) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->residentCode = residentCode; + } + + static constexpr Op OpCode = Op::ImageSparseTexelsResident; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id residentCode; +}; + +struct OpNoLine +{ + OpNoLine(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpNoLine() + : op(Op::NoLine) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::NoLine; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpAtomicFlagTestAndSet +{ + OpAtomicFlagTestAndSet(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicFlagTestAndSet(IdResultType resultType, IdResult result, Id pointer, IdScope memory, IdMemorySemantics semantics) + : op(Op::AtomicFlagTestAndSet) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::AtomicFlagTestAndSet; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpAtomicFlagClear +{ + OpAtomicFlagClear(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAtomicFlagClear(Id pointer, IdScope memory, IdMemorySemantics semantics) + : op(Op::AtomicFlagClear) + , wordCount(FixedWordSize) + { + this->pointer = pointer; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::AtomicFlagClear; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + Id pointer; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpImageSparseRead +{ + OpImageSparseRead(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->image = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->imageOperands = DecodeParam(it, word); + } + OpImageSparseRead(IdResultType resultType, IdResult result, Id image, Id coordinate, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSparseRead) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(image.value()); + words.push_back(coordinate.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSparseRead; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpSizeOf +{ + OpSizeOf(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSizeOf(IdResultType resultType, IdResult result, Id pointer) + : op(Op::SizeOf) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + } + + static constexpr Op OpCode = Op::SizeOf; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; +}; + +struct OpTypePipeStorage +{ + OpTypePipeStorage(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypePipeStorage(IdResult result) + : op(Op::TypePipeStorage) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypePipeStorage; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpConstantPipeStorage +{ + OpConstantPipeStorage(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpConstantPipeStorage(IdResultType resultType, IdResult result, uint32_t packetSize, uint32_t packetAlignment, uint32_t capacity) + : op(Op::ConstantPipeStorage) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packetSize = packetSize; + this->packetAlignment = packetAlignment; + this->capacity = capacity; + } + + static constexpr Op OpCode = Op::ConstantPipeStorage; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + uint32_t packetSize; + uint32_t packetAlignment; + uint32_t capacity; +}; + +struct OpCreatePipeFromPipeStorage +{ + OpCreatePipeFromPipeStorage(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCreatePipeFromPipeStorage(IdResultType resultType, IdResult result, Id pipeStorage) + : op(Op::CreatePipeFromPipeStorage) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->pipeStorage = pipeStorage; + } + + static constexpr Op OpCode = Op::CreatePipeFromPipeStorage; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pipeStorage; +}; + +struct OpGetKernelLocalSizeForSubgroupCount +{ + OpGetKernelLocalSizeForSubgroupCount(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetKernelLocalSizeForSubgroupCount(IdResultType resultType, IdResult result, Id subgroupCount, Id invoke, Id param, Id paramSize, Id paramAlign) + : op(Op::GetKernelLocalSizeForSubgroupCount) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->subgroupCount = subgroupCount; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + } + + static constexpr Op OpCode = Op::GetKernelLocalSizeForSubgroupCount; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id subgroupCount; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; +}; + +struct OpGetKernelMaxNumSubgroups +{ + OpGetKernelMaxNumSubgroups(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGetKernelMaxNumSubgroups(IdResultType resultType, IdResult result, Id invoke, Id param, Id paramSize, Id paramAlign) + : op(Op::GetKernelMaxNumSubgroups) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->invoke = invoke; + this->param = param; + this->paramSize = paramSize; + this->paramAlign = paramAlign; + } + + static constexpr Op OpCode = Op::GetKernelMaxNumSubgroups; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id invoke; + Id param; + Id paramSize; + Id paramAlign; +}; + +struct OpTypeNamedBarrier +{ + OpTypeNamedBarrier(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeNamedBarrier(IdResult result) + : op(Op::TypeNamedBarrier) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeNamedBarrier; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpNamedBarrierInitialize +{ + OpNamedBarrierInitialize(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpNamedBarrierInitialize(IdResultType resultType, IdResult result, Id subgroupCount) + : op(Op::NamedBarrierInitialize) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->subgroupCount = subgroupCount; + } + + static constexpr Op OpCode = Op::NamedBarrierInitialize; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id subgroupCount; +}; + +struct OpMemoryNamedBarrier +{ + OpMemoryNamedBarrier(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpMemoryNamedBarrier(Id namedBarrier, IdScope memory, IdMemorySemantics semantics) + : op(Op::MemoryNamedBarrier) + , wordCount(FixedWordSize) + { + this->namedBarrier = namedBarrier; + this->memory = memory; + this->semantics = semantics; + } + + static constexpr Op OpCode = Op::MemoryNamedBarrier; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + Id namedBarrier; + IdScope memory; + IdMemorySemantics semantics; +}; + +struct OpModuleProcessed +{ + OpModuleProcessed(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + uint32_t word = 1; + this->process = DecodeParam(it, word); + } + OpModuleProcessed(rdcstr process) + : op(Op::ModuleProcessed) + , wordCount(MinWordSize + ExtraWordCount(process)) + { + this->process = process; + } + operator Operation() const + { + std::vector words; + EncodeParam(words, process); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ModuleProcessed; + static constexpr uint16_t MinWordSize = 2U; + Op op; + uint16_t wordCount; + rdcstr process; +}; + +struct OpExecutionModeId +{ + OpExecutionModeId(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->entryPoint = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->mode = DecodeParam(it, word); + } + OpExecutionModeId(Id entryPoint, ExecutionModeAndParamData mode) + : op(Op::ExecutionModeId) + , wordCount(MinWordSize + ExtraWordCount(mode)) + { + this->entryPoint = entryPoint; + this->mode = mode; + } + operator Operation() const + { + std::vector words; + words.push_back(entryPoint.value()); + EncodeParam(words, mode); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ExecutionModeId; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id entryPoint; + ExecutionModeAndParamData mode; +}; + +struct OpDecorateId +{ + OpDecorateId(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->target = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->decoration = DecodeParam(it, word); + } + OpDecorateId(Id target, DecorationAndParamData decoration) + : op(Op::DecorateId) + , wordCount(MinWordSize + ExtraWordCount(decoration)) + { + this->target = target; + this->decoration = decoration; + } + operator Operation() const + { + std::vector words; + words.push_back(target.value()); + EncodeParam(words, decoration); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::DecorateId; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id target; + DecorationAndParamData decoration; +}; + +struct OpGroupNonUniformElect +{ + OpGroupNonUniformElect(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformElect(IdResultType resultType, IdResult result, IdScope execution) + : op(Op::GroupNonUniformElect) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + } + + static constexpr Op OpCode = Op::GroupNonUniformElect; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; +}; + +struct OpGroupNonUniformAll +{ + OpGroupNonUniformAll(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformAll(IdResultType resultType, IdResult result, IdScope execution, Id predicate) + : op(Op::GroupNonUniformAll) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::GroupNonUniformAll; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id predicate; +}; + +struct OpGroupNonUniformAny +{ + OpGroupNonUniformAny(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformAny(IdResultType resultType, IdResult result, IdScope execution, Id predicate) + : op(Op::GroupNonUniformAny) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::GroupNonUniformAny; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id predicate; +}; + +struct OpGroupNonUniformAllEqual +{ + OpGroupNonUniformAllEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformAllEqual(IdResultType resultType, IdResult result, IdScope execution, Id value) + : op(Op::GroupNonUniformAllEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformAllEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; +}; + +struct OpGroupNonUniformBroadcast +{ + OpGroupNonUniformBroadcast(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBroadcast(IdResultType resultType, IdResult result, IdScope execution, Id value, Id id) + : op(Op::GroupNonUniformBroadcast) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->id = id; + } + + static constexpr Op OpCode = Op::GroupNonUniformBroadcast; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id id; +}; + +struct OpGroupNonUniformBroadcastFirst +{ + OpGroupNonUniformBroadcastFirst(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBroadcastFirst(IdResultType resultType, IdResult result, IdScope execution, Id value) + : op(Op::GroupNonUniformBroadcastFirst) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformBroadcastFirst; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; +}; + +struct OpGroupNonUniformBallot +{ + OpGroupNonUniformBallot(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBallot(IdResultType resultType, IdResult result, IdScope execution, Id predicate) + : op(Op::GroupNonUniformBallot) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::GroupNonUniformBallot; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id predicate; +}; + +struct OpGroupNonUniformInverseBallot +{ + OpGroupNonUniformInverseBallot(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformInverseBallot(IdResultType resultType, IdResult result, IdScope execution, Id value) + : op(Op::GroupNonUniformInverseBallot) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformInverseBallot; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; +}; + +struct OpGroupNonUniformBallotBitExtract +{ + OpGroupNonUniformBallotBitExtract(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBallotBitExtract(IdResultType resultType, IdResult result, IdScope execution, Id value, Id index) + : op(Op::GroupNonUniformBallotBitExtract) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->index = index; + } + + static constexpr Op OpCode = Op::GroupNonUniformBallotBitExtract; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id index; +}; + +struct OpGroupNonUniformBallotBitCount +{ + OpGroupNonUniformBallotBitCount(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBallotBitCount(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value) + : op(Op::GroupNonUniformBallotBitCount) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformBallotBitCount; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; +}; + +struct OpGroupNonUniformBallotFindLSB +{ + OpGroupNonUniformBallotFindLSB(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBallotFindLSB(IdResultType resultType, IdResult result, IdScope execution, Id value) + : op(Op::GroupNonUniformBallotFindLSB) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformBallotFindLSB; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; +}; + +struct OpGroupNonUniformBallotFindMSB +{ + OpGroupNonUniformBallotFindMSB(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformBallotFindMSB(IdResultType resultType, IdResult result, IdScope execution, Id value) + : op(Op::GroupNonUniformBallotFindMSB) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformBallotFindMSB; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; +}; + +struct OpGroupNonUniformShuffle +{ + OpGroupNonUniformShuffle(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformShuffle(IdResultType resultType, IdResult result, IdScope execution, Id value, Id id) + : op(Op::GroupNonUniformShuffle) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->id = id; + } + + static constexpr Op OpCode = Op::GroupNonUniformShuffle; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id id; +}; + +struct OpGroupNonUniformShuffleXor +{ + OpGroupNonUniformShuffleXor(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformShuffleXor(IdResultType resultType, IdResult result, IdScope execution, Id value, Id mask) + : op(Op::GroupNonUniformShuffleXor) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->mask = mask; + } + + static constexpr Op OpCode = Op::GroupNonUniformShuffleXor; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id mask; +}; + +struct OpGroupNonUniformShuffleUp +{ + OpGroupNonUniformShuffleUp(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformShuffleUp(IdResultType resultType, IdResult result, IdScope execution, Id value, Id delta) + : op(Op::GroupNonUniformShuffleUp) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->delta = delta; + } + + static constexpr Op OpCode = Op::GroupNonUniformShuffleUp; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id delta; +}; + +struct OpGroupNonUniformShuffleDown +{ + OpGroupNonUniformShuffleDown(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformShuffleDown(IdResultType resultType, IdResult result, IdScope execution, Id value, Id delta) + : op(Op::GroupNonUniformShuffleDown) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->delta = delta; + } + + static constexpr Op OpCode = Op::GroupNonUniformShuffleDown; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id delta; +}; + +struct OpGroupNonUniformIAdd +{ + OpGroupNonUniformIAdd(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformIAdd(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformIAdd) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformIAdd; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformFAdd +{ + OpGroupNonUniformFAdd(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformFAdd(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformFAdd) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformFAdd; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformIMul +{ + OpGroupNonUniformIMul(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformIMul(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformIMul) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformIMul; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformFMul +{ + OpGroupNonUniformFMul(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformFMul(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformFMul) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformFMul; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformSMin +{ + OpGroupNonUniformSMin(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformSMin(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformSMin) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformSMin; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformUMin +{ + OpGroupNonUniformUMin(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformUMin(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformUMin) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformUMin; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformFMin +{ + OpGroupNonUniformFMin(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformFMin(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformFMin) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformFMin; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformSMax +{ + OpGroupNonUniformSMax(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformSMax(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformSMax) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformSMax; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformUMax +{ + OpGroupNonUniformUMax(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformUMax(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformUMax) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformUMax; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformFMax +{ + OpGroupNonUniformFMax(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformFMax(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformFMax) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformFMax; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformBitwiseAnd +{ + OpGroupNonUniformBitwiseAnd(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformBitwiseAnd(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformBitwiseAnd) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformBitwiseAnd; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformBitwiseOr +{ + OpGroupNonUniformBitwiseOr(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformBitwiseOr(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformBitwiseOr) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformBitwiseOr; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformBitwiseXor +{ + OpGroupNonUniformBitwiseXor(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformBitwiseXor(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformBitwiseXor) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformBitwiseXor; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformLogicalAnd +{ + OpGroupNonUniformLogicalAnd(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformLogicalAnd(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformLogicalAnd) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformLogicalAnd; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformLogicalOr +{ + OpGroupNonUniformLogicalOr(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformLogicalOr(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformLogicalOr) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformLogicalOr; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformLogicalXor +{ + OpGroupNonUniformLogicalXor(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->execution = Id::fromWord(it.word(3)); + this->operation = (GroupOperation)it.word(4); + this->value = Id::fromWord(it.word(5)); + this->clusterSize = (it.size() > 6) ? Id::fromWord(it.word(6)) : Id(); + } + OpGroupNonUniformLogicalXor(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id value, Id clusterSize = Id()) + : op(Op::GroupNonUniformLogicalXor) + , wordCount(MinWordSize + OptionalWordCount(clusterSize)) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->value = value; + this->clusterSize = clusterSize; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(execution.value()); + words.push_back((uint32_t)operation); + words.push_back(value.value()); + if(clusterSize != Id()) words.push_back(clusterSize.value()); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::GroupNonUniformLogicalXor; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id value; + Id clusterSize; + + bool HasClusterSize() const { return wordCount > 6; } +}; + +struct OpGroupNonUniformQuadBroadcast +{ + OpGroupNonUniformQuadBroadcast(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformQuadBroadcast(IdResultType resultType, IdResult result, IdScope execution, Id value, Id index) + : op(Op::GroupNonUniformQuadBroadcast) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->index = index; + } + + static constexpr Op OpCode = Op::GroupNonUniformQuadBroadcast; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id index; +}; + +struct OpGroupNonUniformQuadSwap +{ + OpGroupNonUniformQuadSwap(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformQuadSwap(IdResultType resultType, IdResult result, IdScope execution, Id value, Id direction) + : op(Op::GroupNonUniformQuadSwap) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->value = value; + this->direction = direction; + } + + static constexpr Op OpCode = Op::GroupNonUniformQuadSwap; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + Id value; + Id direction; +}; + +struct OpCopyLogical +{ + OpCopyLogical(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCopyLogical(IdResultType resultType, IdResult result, Id operand) + : op(Op::CopyLogical) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::CopyLogical; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpPtrEqual +{ + OpPtrEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpPtrEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::PtrEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::PtrEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpPtrNotEqual +{ + OpPtrNotEqual(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpPtrNotEqual(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::PtrNotEqual) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::PtrNotEqual; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpPtrDiff +{ + OpPtrDiff(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpPtrDiff(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::PtrDiff) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::PtrDiff; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpSubgroupBallotKHR +{ + OpSubgroupBallotKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupBallotKHR(IdResultType resultType, IdResult result, Id predicate) + : op(Op::SubgroupBallotKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::SubgroupBallotKHR; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id predicate; +}; + +struct OpSubgroupFirstInvocationKHR +{ + OpSubgroupFirstInvocationKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupFirstInvocationKHR(IdResultType resultType, IdResult result, Id value) + : op(Op::SubgroupFirstInvocationKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->value = value; + } + + static constexpr Op OpCode = Op::SubgroupFirstInvocationKHR; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id value; +}; + +struct OpSubgroupAllKHR +{ + OpSubgroupAllKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAllKHR(IdResultType resultType, IdResult result, Id predicate) + : op(Op::SubgroupAllKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::SubgroupAllKHR; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id predicate; +}; + +struct OpSubgroupAnyKHR +{ + OpSubgroupAnyKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAnyKHR(IdResultType resultType, IdResult result, Id predicate) + : op(Op::SubgroupAnyKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::SubgroupAnyKHR; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id predicate; +}; + +struct OpSubgroupAllEqualKHR +{ + OpSubgroupAllEqualKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAllEqualKHR(IdResultType resultType, IdResult result, Id predicate) + : op(Op::SubgroupAllEqualKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->predicate = predicate; + } + + static constexpr Op OpCode = Op::SubgroupAllEqualKHR; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id predicate; +}; + +struct OpSubgroupReadInvocationKHR +{ + OpSubgroupReadInvocationKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupReadInvocationKHR(IdResultType resultType, IdResult result, Id value, Id index) + : op(Op::SubgroupReadInvocationKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->value = value; + this->index = index; + } + + static constexpr Op OpCode = Op::SubgroupReadInvocationKHR; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id value; + Id index; +}; + +struct OpGroupIAddNonUniformAMD +{ + OpGroupIAddNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupIAddNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupIAddNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupIAddNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupFAddNonUniformAMD +{ + OpGroupFAddNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupFAddNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupFAddNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupFAddNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupFMinNonUniformAMD +{ + OpGroupFMinNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupFMinNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupFMinNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupFMinNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupUMinNonUniformAMD +{ + OpGroupUMinNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupUMinNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupUMinNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupUMinNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupSMinNonUniformAMD +{ + OpGroupSMinNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupSMinNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupSMinNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupSMinNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupFMaxNonUniformAMD +{ + OpGroupFMaxNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupFMaxNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupFMaxNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupFMaxNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupUMaxNonUniformAMD +{ + OpGroupUMaxNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupUMaxNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupUMaxNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupUMaxNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpGroupSMaxNonUniformAMD +{ + OpGroupSMaxNonUniformAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupSMaxNonUniformAMD(IdResultType resultType, IdResult result, IdScope execution, GroupOperation operation, Id x) + : op(Op::GroupSMaxNonUniformAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + this->operation = operation; + this->x = x; + } + + static constexpr Op OpCode = Op::GroupSMaxNonUniformAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; + GroupOperation operation; + Id x; +}; + +struct OpFragmentMaskFetchAMD +{ + OpFragmentMaskFetchAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFragmentMaskFetchAMD(IdResultType resultType, IdResult result, Id image, Id coordinate) + : op(Op::FragmentMaskFetchAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + } + + static constexpr Op OpCode = Op::FragmentMaskFetchAMD; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; +}; + +struct OpFragmentFetchAMD +{ + OpFragmentFetchAMD(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpFragmentFetchAMD(IdResultType resultType, IdResult result, Id image, Id coordinate, Id fragmentIndex) + : op(Op::FragmentFetchAMD) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->fragmentIndex = fragmentIndex; + } + + static constexpr Op OpCode = Op::FragmentFetchAMD; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + Id fragmentIndex; +}; + +struct OpReadClockKHR +{ + OpReadClockKHR(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReadClockKHR(IdResultType resultType, IdResult result, IdScope execution) + : op(Op::ReadClockKHR) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->execution = execution; + } + + static constexpr Op OpCode = Op::ReadClockKHR; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + IdScope execution; +}; + +struct OpImageSampleFootprintNV +{ + OpImageSampleFootprintNV(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->sampledImage = Id::fromWord(it.word(3)); + this->coordinate = Id::fromWord(it.word(4)); + this->granularity = Id::fromWord(it.word(5)); + this->coarse = Id::fromWord(it.word(6)); + uint32_t word = 7; + this->imageOperands = DecodeParam(it, word); + } + OpImageSampleFootprintNV(IdResultType resultType, IdResult result, Id sampledImage, Id coordinate, Id granularity, Id coarse, ImageOperandsAndParamDatas imageOperands = ImageOperands::None) + : op(Op::ImageSampleFootprintNV) + , wordCount(MinWordSize + ExtraWordCount(imageOperands)) + { + this->resultType = resultType; + this->result = result; + this->sampledImage = sampledImage; + this->coordinate = coordinate; + this->granularity = granularity; + this->coarse = coarse; + this->imageOperands = imageOperands; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(sampledImage.value()); + words.push_back(coordinate.value()); + words.push_back(granularity.value()); + words.push_back(coarse.value()); + EncodeParam(words, imageOperands); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::ImageSampleFootprintNV; + static constexpr uint16_t MinWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sampledImage; + Id coordinate; + Id granularity; + Id coarse; + ImageOperandsAndParamDatas imageOperands; +}; + +struct OpGroupNonUniformPartitionNV +{ + OpGroupNonUniformPartitionNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpGroupNonUniformPartitionNV(IdResultType resultType, IdResult result, Id value) + : op(Op::GroupNonUniformPartitionNV) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->value = value; + } + + static constexpr Op OpCode = Op::GroupNonUniformPartitionNV; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id value; +}; + +struct OpWritePackedPrimitiveIndices4x8NV +{ + OpWritePackedPrimitiveIndices4x8NV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpWritePackedPrimitiveIndices4x8NV(Id indexOffset, Id packedIndices) + : op(Op::WritePackedPrimitiveIndices4x8NV) + , wordCount(FixedWordSize) + { + this->indexOffset = indexOffset; + this->packedIndices = packedIndices; + } + + static constexpr Op OpCode = Op::WritePackedPrimitiveIndices4x8NV; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id indexOffset; + Id packedIndices; +}; + +struct OpReportIntersectionNV +{ + OpReportIntersectionNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpReportIntersectionNV(IdResultType resultType, IdResult result, Id hit, Id hitKind) + : op(Op::ReportIntersectionNV) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->hit = hit; + this->hitKind = hitKind; + } + + static constexpr Op OpCode = Op::ReportIntersectionNV; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id hit; + Id hitKind; +}; + +struct OpIgnoreIntersectionNV +{ + OpIgnoreIntersectionNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIgnoreIntersectionNV() + : op(Op::IgnoreIntersectionNV) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::IgnoreIntersectionNV; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpTerminateRayNV +{ + OpTerminateRayNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTerminateRayNV() + : op(Op::TerminateRayNV) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::TerminateRayNV; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpTraceNV +{ + OpTraceNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTraceNV(Id accel, Id rayFlags, Id cullMask, Id sBTOffset, Id sBTStride, Id missIndex, Id rayOrigin, Id rayTmin, Id rayDirection, Id rayTmax, Id payloadId) + : op(Op::TraceNV) + , wordCount(FixedWordSize) + { + this->accel = accel; + this->rayFlags = rayFlags; + this->cullMask = cullMask; + this->sBTOffset = sBTOffset; + this->sBTStride = sBTStride; + this->missIndex = missIndex; + this->rayOrigin = rayOrigin; + this->rayTmin = rayTmin; + this->rayDirection = rayDirection; + this->rayTmax = rayTmax; + this->payloadId = payloadId; + } + + static constexpr Op OpCode = Op::TraceNV; + static constexpr uint16_t FixedWordSize = 12U; + Op op; + uint16_t wordCount; + Id accel; + Id rayFlags; + Id cullMask; + Id sBTOffset; + Id sBTStride; + Id missIndex; + Id rayOrigin; + Id rayTmin; + Id rayDirection; + Id rayTmax; + Id payloadId; +}; + +struct OpTypeAccelerationStructureNV +{ + OpTypeAccelerationStructureNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAccelerationStructureNV(IdResult result) + : op(Op::TypeAccelerationStructureNV) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAccelerationStructureNV; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpExecuteCallableNV +{ + OpExecuteCallableNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpExecuteCallableNV(Id sBTIndex, Id callableDataId) + : op(Op::ExecuteCallableNV) + , wordCount(FixedWordSize) + { + this->sBTIndex = sBTIndex; + this->callableDataId = callableDataId; + } + + static constexpr Op OpCode = Op::ExecuteCallableNV; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id sBTIndex; + Id callableDataId; +}; + +struct OpTypeCooperativeMatrixNV +{ + OpTypeCooperativeMatrixNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeCooperativeMatrixNV(IdResult result, Id componentType, IdScope execution, Id rows, Id columns) + : op(Op::TypeCooperativeMatrixNV) + , wordCount(FixedWordSize) + { + this->result = result; + this->componentType = componentType; + this->execution = execution; + this->rows = rows; + this->columns = columns; + } + + static constexpr Op OpCode = Op::TypeCooperativeMatrixNV; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResult result; + Id componentType; + IdScope execution; + Id rows; + Id columns; +}; + +struct OpCooperativeMatrixLoadNV +{ + OpCooperativeMatrixLoadNV(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->resultType = Id::fromWord(it.word(1)); + this->result = Id::fromWord(it.word(2)); + this->pointer = Id::fromWord(it.word(3)); + this->stride = Id::fromWord(it.word(4)); + this->columnMajor = Id::fromWord(it.word(5)); + uint32_t word = 6; + this->memoryAccess = DecodeParam(it, word); + } + OpCooperativeMatrixLoadNV(IdResultType resultType, IdResult result, Id pointer, Id stride, Id columnMajor, MemoryAccessAndParamDatas memoryAccess = MemoryAccess::None) + : op(Op::CooperativeMatrixLoadNV) + , wordCount(MinWordSize + ExtraWordCount(memoryAccess)) + { + this->resultType = resultType; + this->result = result; + this->pointer = pointer; + this->stride = stride; + this->columnMajor = columnMajor; + this->memoryAccess = memoryAccess; + } + operator Operation() const + { + std::vector words; + words.push_back(resultType.value()); + words.push_back(result.value()); + words.push_back(pointer.value()); + words.push_back(stride.value()); + words.push_back(columnMajor.value()); + EncodeParam(words, memoryAccess); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CooperativeMatrixLoadNV; + static constexpr uint16_t MinWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id pointer; + Id stride; + Id columnMajor; + MemoryAccessAndParamDatas memoryAccess; +}; + +struct OpCooperativeMatrixStoreNV +{ + OpCooperativeMatrixStoreNV(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->pointer = Id::fromWord(it.word(1)); + this->object = Id::fromWord(it.word(2)); + this->stride = Id::fromWord(it.word(3)); + this->columnMajor = Id::fromWord(it.word(4)); + uint32_t word = 5; + this->memoryAccess = DecodeParam(it, word); + } + OpCooperativeMatrixStoreNV(Id pointer, Id object, Id stride, Id columnMajor, MemoryAccessAndParamDatas memoryAccess = MemoryAccess::None) + : op(Op::CooperativeMatrixStoreNV) + , wordCount(MinWordSize + ExtraWordCount(memoryAccess)) + { + this->pointer = pointer; + this->object = object; + this->stride = stride; + this->columnMajor = columnMajor; + this->memoryAccess = memoryAccess; + } + operator Operation() const + { + std::vector words; + words.push_back(pointer.value()); + words.push_back(object.value()); + words.push_back(stride.value()); + words.push_back(columnMajor.value()); + EncodeParam(words, memoryAccess); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::CooperativeMatrixStoreNV; + static constexpr uint16_t MinWordSize = 5U; + Op op; + uint16_t wordCount; + Id pointer; + Id object; + Id stride; + Id columnMajor; + MemoryAccessAndParamDatas memoryAccess; +}; + +struct OpCooperativeMatrixMulAddNV +{ + OpCooperativeMatrixMulAddNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCooperativeMatrixMulAddNV(IdResultType resultType, IdResult result, Id a, Id b, Id c) + : op(Op::CooperativeMatrixMulAddNV) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->a = a; + this->b = b; + this->c = c; + } + + static constexpr Op OpCode = Op::CooperativeMatrixMulAddNV; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id a; + Id b; + Id c; +}; + +struct OpCooperativeMatrixLengthNV +{ + OpCooperativeMatrixLengthNV(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpCooperativeMatrixLengthNV(IdResultType resultType, IdResult result, Id type) + : op(Op::CooperativeMatrixLengthNV) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->type = type; + } + + static constexpr Op OpCode = Op::CooperativeMatrixLengthNV; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id type; +}; + +struct OpBeginInvocationInterlockEXT +{ + OpBeginInvocationInterlockEXT(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpBeginInvocationInterlockEXT() + : op(Op::BeginInvocationInterlockEXT) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::BeginInvocationInterlockEXT; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpEndInvocationInterlockEXT +{ + OpEndInvocationInterlockEXT(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpEndInvocationInterlockEXT() + : op(Op::EndInvocationInterlockEXT) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::EndInvocationInterlockEXT; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpDemoteToHelperInvocationEXT +{ + OpDemoteToHelperInvocationEXT(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpDemoteToHelperInvocationEXT() + : op(Op::DemoteToHelperInvocationEXT) + , wordCount(FixedWordSize) + { + // no operands + } + + static constexpr Op OpCode = Op::DemoteToHelperInvocationEXT; + static constexpr uint16_t FixedWordSize = 1U; + Op op; + uint16_t wordCount; + // no operands +}; + +struct OpIsHelperInvocationEXT +{ + OpIsHelperInvocationEXT(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIsHelperInvocationEXT(IdResultType resultType, IdResult result) + : op(Op::IsHelperInvocationEXT) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::IsHelperInvocationEXT; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSubgroupShuffleINTEL +{ + OpSubgroupShuffleINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupShuffleINTEL(IdResultType resultType, IdResult result, Id data, Id invocationId) + : op(Op::SubgroupShuffleINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->data = data; + this->invocationId = invocationId; + } + + static constexpr Op OpCode = Op::SubgroupShuffleINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id data; + Id invocationId; +}; + +struct OpSubgroupShuffleDownINTEL +{ + OpSubgroupShuffleDownINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupShuffleDownINTEL(IdResultType resultType, IdResult result, Id current, Id next, Id delta) + : op(Op::SubgroupShuffleDownINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->current = current; + this->next = next; + this->delta = delta; + } + + static constexpr Op OpCode = Op::SubgroupShuffleDownINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id current; + Id next; + Id delta; +}; + +struct OpSubgroupShuffleUpINTEL +{ + OpSubgroupShuffleUpINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupShuffleUpINTEL(IdResultType resultType, IdResult result, Id previous, Id current, Id delta) + : op(Op::SubgroupShuffleUpINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->previous = previous; + this->current = current; + this->delta = delta; + } + + static constexpr Op OpCode = Op::SubgroupShuffleUpINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id previous; + Id current; + Id delta; +}; + +struct OpSubgroupShuffleXorINTEL +{ + OpSubgroupShuffleXorINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupShuffleXorINTEL(IdResultType resultType, IdResult result, Id data, Id value) + : op(Op::SubgroupShuffleXorINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->data = data; + this->value = value; + } + + static constexpr Op OpCode = Op::SubgroupShuffleXorINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id data; + Id value; +}; + +struct OpSubgroupBlockReadINTEL +{ + OpSubgroupBlockReadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupBlockReadINTEL(IdResultType resultType, IdResult result, Id ptr) + : op(Op::SubgroupBlockReadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->ptr = ptr; + } + + static constexpr Op OpCode = Op::SubgroupBlockReadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id ptr; +}; + +struct OpSubgroupBlockWriteINTEL +{ + OpSubgroupBlockWriteINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupBlockWriteINTEL(Id ptr, Id data) + : op(Op::SubgroupBlockWriteINTEL) + , wordCount(FixedWordSize) + { + this->ptr = ptr; + this->data = data; + } + + static constexpr Op OpCode = Op::SubgroupBlockWriteINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + Id ptr; + Id data; +}; + +struct OpSubgroupImageBlockReadINTEL +{ + OpSubgroupImageBlockReadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupImageBlockReadINTEL(IdResultType resultType, IdResult result, Id image, Id coordinate) + : op(Op::SubgroupImageBlockReadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + } + + static constexpr Op OpCode = Op::SubgroupImageBlockReadINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; +}; + +struct OpSubgroupImageBlockWriteINTEL +{ + OpSubgroupImageBlockWriteINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupImageBlockWriteINTEL(Id image, Id coordinate, Id data) + : op(Op::SubgroupImageBlockWriteINTEL) + , wordCount(FixedWordSize) + { + this->image = image; + this->coordinate = coordinate; + this->data = data; + } + + static constexpr Op OpCode = Op::SubgroupImageBlockWriteINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + Id image; + Id coordinate; + Id data; +}; + +struct OpSubgroupImageMediaBlockReadINTEL +{ + OpSubgroupImageMediaBlockReadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupImageMediaBlockReadINTEL(IdResultType resultType, IdResult result, Id image, Id coordinate, Id width, Id height) + : op(Op::SubgroupImageMediaBlockReadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->image = image; + this->coordinate = coordinate; + this->width = width; + this->height = height; + } + + static constexpr Op OpCode = Op::SubgroupImageMediaBlockReadINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id image; + Id coordinate; + Id width; + Id height; +}; + +struct OpSubgroupImageMediaBlockWriteINTEL +{ + OpSubgroupImageMediaBlockWriteINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupImageMediaBlockWriteINTEL(Id image, Id coordinate, Id width, Id height, Id data) + : op(Op::SubgroupImageMediaBlockWriteINTEL) + , wordCount(FixedWordSize) + { + this->image = image; + this->coordinate = coordinate; + this->width = width; + this->height = height; + this->data = data; + } + + static constexpr Op OpCode = Op::SubgroupImageMediaBlockWriteINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + Id image; + Id coordinate; + Id width; + Id height; + Id data; +}; + +struct OpUCountLeadingZerosINTEL +{ + OpUCountLeadingZerosINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUCountLeadingZerosINTEL(IdResultType resultType, IdResult result, Id operand) + : op(Op::UCountLeadingZerosINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::UCountLeadingZerosINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpUCountTrailingZerosINTEL +{ + OpUCountTrailingZerosINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUCountTrailingZerosINTEL(IdResultType resultType, IdResult result, Id operand) + : op(Op::UCountTrailingZerosINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand = operand; + } + + static constexpr Op OpCode = Op::UCountTrailingZerosINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand; +}; + +struct OpAbsISubINTEL +{ + OpAbsISubINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAbsISubINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::AbsISubINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::AbsISubINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpAbsUSubINTEL +{ + OpAbsUSubINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpAbsUSubINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::AbsUSubINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::AbsUSubINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpIAddSatINTEL +{ + OpIAddSatINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIAddSatINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IAddSatINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IAddSatINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUAddSatINTEL +{ + OpUAddSatINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUAddSatINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UAddSatINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UAddSatINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpIAverageINTEL +{ + OpIAverageINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIAverageINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IAverageINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IAverageINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUAverageINTEL +{ + OpUAverageINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUAverageINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UAverageINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UAverageINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpIAverageRoundedINTEL +{ + OpIAverageRoundedINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIAverageRoundedINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IAverageRoundedINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IAverageRoundedINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUAverageRoundedINTEL +{ + OpUAverageRoundedINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUAverageRoundedINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UAverageRoundedINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UAverageRoundedINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpISubSatINTEL +{ + OpISubSatINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpISubSatINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::ISubSatINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::ISubSatINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUSubSatINTEL +{ + OpUSubSatINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUSubSatINTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::USubSatINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::USubSatINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpIMul32x16INTEL +{ + OpIMul32x16INTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpIMul32x16INTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::IMul32x16INTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::IMul32x16INTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpUMul32x16INTEL +{ + OpUMul32x16INTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpUMul32x16INTEL(IdResultType resultType, IdResult result, Id operand1, Id operand2) + : op(Op::UMul32x16INTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->operand1 = operand1; + this->operand2 = operand2; + } + + static constexpr Op OpCode = Op::UMul32x16INTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id operand1; + Id operand2; +}; + +struct OpDecorateString +{ + OpDecorateString(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->target = Id::fromWord(it.word(1)); + uint32_t word = 2; + this->decoration = DecodeParam(it, word); + } + OpDecorateString(Id target, DecorationAndParamData decoration) + : op(Op::DecorateString) + , wordCount(MinWordSize + ExtraWordCount(decoration)) + { + this->target = target; + this->decoration = decoration; + } + operator Operation() const + { + std::vector words; + words.push_back(target.value()); + EncodeParam(words, decoration); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::DecorateString; + static constexpr uint16_t MinWordSize = 3U; + Op op; + uint16_t wordCount; + Id target; + DecorationAndParamData decoration; +}; + +struct OpMemberDecorateString +{ + OpMemberDecorateString(const ConstIter &it) + { + this->op = OpCode; + this->wordCount = (uint16_t)it.size(); + this->structType = Id::fromWord(it.word(1)); + this->member = (uint32_t)it.word(2); + uint32_t word = 3; + this->decoration = DecodeParam(it, word); + } + OpMemberDecorateString(Id structType, uint32_t member, DecorationAndParamData decoration) + : op(Op::MemberDecorateString) + , wordCount(MinWordSize + ExtraWordCount(decoration)) + { + this->structType = structType; + this->member = member; + this->decoration = decoration; + } + operator Operation() const + { + std::vector words; + words.push_back(structType.value()); + words.push_back((uint32_t)member); + EncodeParam(words, decoration); + return Operation(OpCode, words); + } + + static constexpr Op OpCode = Op::MemberDecorateString; + static constexpr uint16_t MinWordSize = 4U; + Op op; + uint16_t wordCount; + Id structType; + uint32_t member; + DecorationAndParamData decoration; +}; + +struct OpVmeImageINTEL +{ + OpVmeImageINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpVmeImageINTEL(IdResultType resultType, IdResult result, Id imageType, Id sampler) + : op(Op::VmeImageINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->imageType = imageType; + this->sampler = sampler; + } + + static constexpr Op OpCode = Op::VmeImageINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id imageType; + Id sampler; +}; + +struct OpTypeVmeImageINTEL +{ + OpTypeVmeImageINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeVmeImageINTEL(IdResult result, Id imageType) + : op(Op::TypeVmeImageINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + this->imageType = imageType; + } + + static constexpr Op OpCode = Op::TypeVmeImageINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResult result; + Id imageType; +}; + +struct OpTypeAvcImePayloadINTEL +{ + OpTypeAvcImePayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcImePayloadINTEL(IdResult result) + : op(Op::TypeAvcImePayloadINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcImePayloadINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcRefPayloadINTEL +{ + OpTypeAvcRefPayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcRefPayloadINTEL(IdResult result) + : op(Op::TypeAvcRefPayloadINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcRefPayloadINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcSicPayloadINTEL +{ + OpTypeAvcSicPayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcSicPayloadINTEL(IdResult result) + : op(Op::TypeAvcSicPayloadINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcSicPayloadINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcMcePayloadINTEL +{ + OpTypeAvcMcePayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcMcePayloadINTEL(IdResult result) + : op(Op::TypeAvcMcePayloadINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcMcePayloadINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcMceResultINTEL +{ + OpTypeAvcMceResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcMceResultINTEL(IdResult result) + : op(Op::TypeAvcMceResultINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcMceResultINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcImeResultINTEL +{ + OpTypeAvcImeResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcImeResultINTEL(IdResult result) + : op(Op::TypeAvcImeResultINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcImeResultINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcImeResultSingleReferenceStreamoutINTEL +{ + OpTypeAvcImeResultSingleReferenceStreamoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcImeResultSingleReferenceStreamoutINTEL(IdResult result) + : op(Op::TypeAvcImeResultSingleReferenceStreamoutINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcImeResultSingleReferenceStreamoutINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcImeResultDualReferenceStreamoutINTEL +{ + OpTypeAvcImeResultDualReferenceStreamoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcImeResultDualReferenceStreamoutINTEL(IdResult result) + : op(Op::TypeAvcImeResultDualReferenceStreamoutINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcImeResultDualReferenceStreamoutINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcImeSingleReferenceStreaminINTEL +{ + OpTypeAvcImeSingleReferenceStreaminINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcImeSingleReferenceStreaminINTEL(IdResult result) + : op(Op::TypeAvcImeSingleReferenceStreaminINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcImeSingleReferenceStreaminINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcImeDualReferenceStreaminINTEL +{ + OpTypeAvcImeDualReferenceStreaminINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcImeDualReferenceStreaminINTEL(IdResult result) + : op(Op::TypeAvcImeDualReferenceStreaminINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcImeDualReferenceStreaminINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcRefResultINTEL +{ + OpTypeAvcRefResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcRefResultINTEL(IdResult result) + : op(Op::TypeAvcRefResultINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcRefResultINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpTypeAvcSicResultINTEL +{ + OpTypeAvcSicResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpTypeAvcSicResultINTEL(IdResult result) + : op(Op::TypeAvcSicResultINTEL) + , wordCount(FixedWordSize) + { + this->result = result; + } + + static constexpr Op OpCode = Op::TypeAvcSicResultINTEL; + static constexpr uint16_t FixedWordSize = 2U; + Op op; + uint16_t wordCount; + IdResult result; +}; + +struct OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL(IdResultType resultType, IdResult result, Id sliceType, Id qp) + : op(Op::SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sliceType = sliceType; + this->qp = qp; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sliceType; + Id qp; +}; + +struct OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL +{ + OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL(IdResultType resultType, IdResult result, Id referenceBasePenalty, Id payload) + : op(Op::SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->referenceBasePenalty = referenceBasePenalty; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id referenceBasePenalty; + Id payload; +}; + +struct OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL(IdResultType resultType, IdResult result, Id sliceType, Id qp) + : op(Op::SubgroupAvcMceGetDefaultInterShapePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sliceType = sliceType; + this->qp = qp; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultInterShapePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sliceType; + Id qp; +}; + +struct OpSubgroupAvcMceSetInterShapePenaltyINTEL +{ + OpSubgroupAvcMceSetInterShapePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetInterShapePenaltyINTEL(IdResultType resultType, IdResult result, Id packedShapePenalty, Id payload) + : op(Op::SubgroupAvcMceSetInterShapePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packedShapePenalty = packedShapePenalty; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetInterShapePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id packedShapePenalty; + Id payload; +}; + +struct OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL(IdResultType resultType, IdResult result, Id sliceType, Id qp) + : op(Op::SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sliceType = sliceType; + this->qp = qp; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sliceType; + Id qp; +}; + +struct OpSubgroupAvcMceSetInterDirectionPenaltyINTEL +{ + OpSubgroupAvcMceSetInterDirectionPenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetInterDirectionPenaltyINTEL(IdResultType resultType, IdResult result, Id directionCost, Id payload) + : op(Op::SubgroupAvcMceSetInterDirectionPenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->directionCost = directionCost; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetInterDirectionPenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id directionCost; + Id payload; +}; + +struct OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL(IdResultType resultType, IdResult result, Id sliceType, Id qp) + : op(Op::SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sliceType = sliceType; + this->qp = qp; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sliceType; + Id qp; +}; + +struct OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL +{ + OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL(IdResultType resultType, IdResult result, Id sliceType, Id qp) + : op(Op::SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sliceType = sliceType; + this->qp = qp; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sliceType; + Id qp; +}; + +struct OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL +{ + OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL(IdResultType resultType, IdResult result) + : op(Op::SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL +{ + OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL(IdResultType resultType, IdResult result) + : op(Op::SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL +{ + OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL(IdResultType resultType, IdResult result) + : op(Op::SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL +{ + OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL(IdResultType resultType, IdResult result, Id packedCostCenterDelta, Id packedCostTable, Id costPrecision, Id payload) + : op(Op::SubgroupAvcMceSetMotionVectorCostFunctionINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packedCostCenterDelta = packedCostCenterDelta; + this->packedCostTable = packedCostTable; + this->costPrecision = costPrecision; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetMotionVectorCostFunctionINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id packedCostCenterDelta; + Id packedCostTable; + Id costPrecision; + Id payload; +}; + +struct OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL(IdResultType resultType, IdResult result, Id sliceType, Id qp) + : op(Op::SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sliceType = sliceType; + this->qp = qp; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sliceType; + Id qp; +}; + +struct OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL(IdResultType resultType, IdResult result) + : op(Op::SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL +{ + OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL(IdResultType resultType, IdResult result) + : op(Op::SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 3U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; +}; + +struct OpSubgroupAvcMceSetAcOnlyHaarINTEL +{ + OpSubgroupAvcMceSetAcOnlyHaarINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetAcOnlyHaarINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceSetAcOnlyHaarINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetAcOnlyHaarINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL +{ + OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL(IdResultType resultType, IdResult result, Id sourceFieldPolarity, Id payload) + : op(Op::SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->sourceFieldPolarity = sourceFieldPolarity; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id sourceFieldPolarity; + Id payload; +}; + +struct OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL +{ + OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL(IdResultType resultType, IdResult result, Id referenceFieldPolarity, Id payload) + : op(Op::SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->referenceFieldPolarity = referenceFieldPolarity; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id referenceFieldPolarity; + Id payload; +}; + +struct OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL +{ + OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL(IdResultType resultType, IdResult result, Id forwardReferenceFieldPolarity, Id backwardReferenceFieldPolarity, Id payload) + : op(Op::SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->forwardReferenceFieldPolarity = forwardReferenceFieldPolarity; + this->backwardReferenceFieldPolarity = backwardReferenceFieldPolarity; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id forwardReferenceFieldPolarity; + Id backwardReferenceFieldPolarity; + Id payload; +}; + +struct OpSubgroupAvcMceConvertToImePayloadINTEL +{ + OpSubgroupAvcMceConvertToImePayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceConvertToImePayloadINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceConvertToImePayloadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceConvertToImePayloadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceConvertToImeResultINTEL +{ + OpSubgroupAvcMceConvertToImeResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceConvertToImeResultINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceConvertToImeResultINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceConvertToImeResultINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceConvertToRefPayloadINTEL +{ + OpSubgroupAvcMceConvertToRefPayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceConvertToRefPayloadINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceConvertToRefPayloadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceConvertToRefPayloadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceConvertToRefResultINTEL +{ + OpSubgroupAvcMceConvertToRefResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceConvertToRefResultINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceConvertToRefResultINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceConvertToRefResultINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceConvertToSicPayloadINTEL +{ + OpSubgroupAvcMceConvertToSicPayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceConvertToSicPayloadINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceConvertToSicPayloadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceConvertToSicPayloadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceConvertToSicResultINTEL +{ + OpSubgroupAvcMceConvertToSicResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceConvertToSicResultINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceConvertToSicResultINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceConvertToSicResultINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetMotionVectorsINTEL +{ + OpSubgroupAvcMceGetMotionVectorsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetMotionVectorsINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetMotionVectorsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetMotionVectorsINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterDistortionsINTEL +{ + OpSubgroupAvcMceGetInterDistortionsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterDistortionsINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetInterDistortionsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterDistortionsINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetBestInterDistortionsINTEL +{ + OpSubgroupAvcMceGetBestInterDistortionsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetBestInterDistortionsINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetBestInterDistortionsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetBestInterDistortionsINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterMajorShapeINTEL +{ + OpSubgroupAvcMceGetInterMajorShapeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterMajorShapeINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetInterMajorShapeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterMajorShapeINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterMinorShapeINTEL +{ + OpSubgroupAvcMceGetInterMinorShapeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterMinorShapeINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetInterMinorShapeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterMinorShapeINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterDirectionsINTEL +{ + OpSubgroupAvcMceGetInterDirectionsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterDirectionsINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetInterDirectionsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterDirectionsINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterMotionVectorCountINTEL +{ + OpSubgroupAvcMceGetInterMotionVectorCountINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterMotionVectorCountINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetInterMotionVectorCountINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterMotionVectorCountINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterReferenceIdsINTEL +{ + OpSubgroupAvcMceGetInterReferenceIdsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterReferenceIdsINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcMceGetInterReferenceIdsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterReferenceIdsINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL +{ + OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL(IdResultType resultType, IdResult result, Id packedReferenceIds, Id packedReferenceParameterFieldPolarities, Id payload) + : op(Op::SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packedReferenceIds = packedReferenceIds; + this->packedReferenceParameterFieldPolarities = packedReferenceParameterFieldPolarities; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id packedReferenceIds; + Id packedReferenceParameterFieldPolarities; + Id payload; +}; + +struct OpSubgroupAvcImeInitializeINTEL +{ + OpSubgroupAvcImeInitializeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeInitializeINTEL(IdResultType resultType, IdResult result, Id srcCoord, Id partitionMask, Id sADAdjustment) + : op(Op::SubgroupAvcImeInitializeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcCoord = srcCoord; + this->partitionMask = partitionMask; + this->sADAdjustment = sADAdjustment; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeInitializeINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcCoord; + Id partitionMask; + Id sADAdjustment; +}; + +struct OpSubgroupAvcImeSetSingleReferenceINTEL +{ + OpSubgroupAvcImeSetSingleReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeSetSingleReferenceINTEL(IdResultType resultType, IdResult result, Id refOffset, Id searchWindowConfig, Id payload) + : op(Op::SubgroupAvcImeSetSingleReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->refOffset = refOffset; + this->searchWindowConfig = searchWindowConfig; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeSetSingleReferenceINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id refOffset; + Id searchWindowConfig; + Id payload; +}; + +struct OpSubgroupAvcImeSetDualReferenceINTEL +{ + OpSubgroupAvcImeSetDualReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeSetDualReferenceINTEL(IdResultType resultType, IdResult result, Id fwdRefOffset, Id bwdRefOffset, Id idSearchWindowConfig, Id payload) + : op(Op::SubgroupAvcImeSetDualReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->fwdRefOffset = fwdRefOffset; + this->bwdRefOffset = bwdRefOffset; + this->idSearchWindowConfig = idSearchWindowConfig; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeSetDualReferenceINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id fwdRefOffset; + Id bwdRefOffset; + Id idSearchWindowConfig; + Id payload; +}; + +struct OpSubgroupAvcImeRefWindowSizeINTEL +{ + OpSubgroupAvcImeRefWindowSizeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeRefWindowSizeINTEL(IdResultType resultType, IdResult result, Id searchWindowConfig, Id dualRef) + : op(Op::SubgroupAvcImeRefWindowSizeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->searchWindowConfig = searchWindowConfig; + this->dualRef = dualRef; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeRefWindowSizeINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id searchWindowConfig; + Id dualRef; +}; + +struct OpSubgroupAvcImeAdjustRefOffsetINTEL +{ + OpSubgroupAvcImeAdjustRefOffsetINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeAdjustRefOffsetINTEL(IdResultType resultType, IdResult result, Id refOffset, Id srcCoord, Id refWindowSize, Id imageSize) + : op(Op::SubgroupAvcImeAdjustRefOffsetINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->refOffset = refOffset; + this->srcCoord = srcCoord; + this->refWindowSize = refWindowSize; + this->imageSize = imageSize; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeAdjustRefOffsetINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id refOffset; + Id srcCoord; + Id refWindowSize; + Id imageSize; +}; + +struct OpSubgroupAvcImeConvertToMcePayloadINTEL +{ + OpSubgroupAvcImeConvertToMcePayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeConvertToMcePayloadINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeConvertToMcePayloadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeConvertToMcePayloadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeSetMaxMotionVectorCountINTEL +{ + OpSubgroupAvcImeSetMaxMotionVectorCountINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeSetMaxMotionVectorCountINTEL(IdResultType resultType, IdResult result, Id maxMotionVectorCount, Id payload) + : op(Op::SubgroupAvcImeSetMaxMotionVectorCountINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->maxMotionVectorCount = maxMotionVectorCount; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeSetMaxMotionVectorCountINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id maxMotionVectorCount; + Id payload; +}; + +struct OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL +{ + OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeSetUnidirectionalMixDisableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeSetUnidirectionalMixDisableINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL +{ + OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL(IdResultType resultType, IdResult result, Id threshold, Id payload) + : op(Op::SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->threshold = threshold; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id threshold; + Id payload; +}; + +struct OpSubgroupAvcImeSetWeightedSadINTEL +{ + OpSubgroupAvcImeSetWeightedSadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeSetWeightedSadINTEL(IdResultType resultType, IdResult result, Id packedSadWeights, Id payload) + : op(Op::SubgroupAvcImeSetWeightedSadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packedSadWeights = packedSadWeights; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeSetWeightedSadINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id packedSadWeights; + Id payload; +}; + +struct OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL +{ + OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id refImage, Id payload) + : op(Op::SubgroupAvcImeEvaluateWithSingleReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->refImage = refImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithSingleReferenceINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id refImage; + Id payload; +}; + +struct OpSubgroupAvcImeEvaluateWithDualReferenceINTEL +{ + OpSubgroupAvcImeEvaluateWithDualReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithDualReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id fwdRefImage, Id bwdRefImage, Id payload) + : op(Op::SubgroupAvcImeEvaluateWithDualReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->fwdRefImage = fwdRefImage; + this->bwdRefImage = bwdRefImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithDualReferenceINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id fwdRefImage; + Id bwdRefImage; + Id payload; +}; + +struct OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL +{ + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL(IdResultType resultType, IdResult result, Id srcImage, Id refImage, Id payload, Id streaminComponents) + : op(Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->refImage = refImage; + this->payload = payload; + this->streaminComponents = streaminComponents; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id refImage; + Id payload; + Id streaminComponents; +}; + +struct OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL +{ + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL(IdResultType resultType, IdResult result, Id srcImage, Id fwdRefImage, Id bwdRefImage, Id payload, Id streaminComponents) + : op(Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->fwdRefImage = fwdRefImage; + this->bwdRefImage = bwdRefImage; + this->payload = payload; + this->streaminComponents = streaminComponents; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id fwdRefImage; + Id bwdRefImage; + Id payload; + Id streaminComponents; +}; + +struct OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL +{ + OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL(IdResultType resultType, IdResult result, Id srcImage, Id refImage, Id payload) + : op(Op::SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->refImage = refImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id refImage; + Id payload; +}; + +struct OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL +{ + OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL(IdResultType resultType, IdResult result, Id srcImage, Id fwdRefImage, Id bwdRefImage, Id payload) + : op(Op::SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->fwdRefImage = fwdRefImage; + this->bwdRefImage = bwdRefImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id fwdRefImage; + Id bwdRefImage; + Id payload; +}; + +struct OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL +{ + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL(IdResultType resultType, IdResult result, Id srcImage, Id refImage, Id payload, Id streaminComponents) + : op(Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->refImage = refImage; + this->payload = payload; + this->streaminComponents = streaminComponents; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id refImage; + Id payload; + Id streaminComponents; +}; + +struct OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL +{ + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL(IdResultType resultType, IdResult result, Id srcImage, Id fwdRefImage, Id bwdRefImage, Id payload, Id streaminComponents) + : op(Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->fwdRefImage = fwdRefImage; + this->bwdRefImage = bwdRefImage; + this->payload = payload; + this->streaminComponents = streaminComponents; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL; + static constexpr uint16_t FixedWordSize = 8U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id fwdRefImage; + Id bwdRefImage; + Id payload; + Id streaminComponents; +}; + +struct OpSubgroupAvcImeConvertToMceResultINTEL +{ + OpSubgroupAvcImeConvertToMceResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeConvertToMceResultINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeConvertToMceResultINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeConvertToMceResultINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeGetSingleReferenceStreaminINTEL +{ + OpSubgroupAvcImeGetSingleReferenceStreaminINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetSingleReferenceStreaminINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeGetSingleReferenceStreaminINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetSingleReferenceStreaminINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeGetDualReferenceStreaminINTEL +{ + OpSubgroupAvcImeGetDualReferenceStreaminINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetDualReferenceStreaminINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeGetDualReferenceStreaminINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetDualReferenceStreaminINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL +{ + OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeStripSingleReferenceStreamoutINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeStripSingleReferenceStreamoutINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeStripDualReferenceStreamoutINTEL +{ + OpSubgroupAvcImeStripDualReferenceStreamoutINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeStripDualReferenceStreamoutINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeStripDualReferenceStreamoutINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeStripDualReferenceStreamoutINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL +{ + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL(IdResultType resultType, IdResult result, Id payload, Id majorShape) + : op(Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + this->majorShape = majorShape; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; + Id majorShape; +}; + +struct OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL +{ + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL(IdResultType resultType, IdResult result, Id payload, Id majorShape) + : op(Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + this->majorShape = majorShape; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; + Id majorShape; +}; + +struct OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL +{ + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL(IdResultType resultType, IdResult result, Id payload, Id majorShape) + : op(Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + this->majorShape = majorShape; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; + Id majorShape; +}; + +struct OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL +{ + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL(IdResultType resultType, IdResult result, Id payload, Id majorShape, Id direction) + : op(Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + this->majorShape = majorShape; + this->direction = direction; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; + Id majorShape; + Id direction; +}; + +struct OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL +{ + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL(IdResultType resultType, IdResult result, Id payload, Id majorShape, Id direction) + : op(Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + this->majorShape = majorShape; + this->direction = direction; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; + Id majorShape; + Id direction; +}; + +struct OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL +{ + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL(IdResultType resultType, IdResult result, Id payload, Id majorShape, Id direction) + : op(Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + this->majorShape = majorShape; + this->direction = direction; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; + Id majorShape; + Id direction; +}; + +struct OpSubgroupAvcImeGetBorderReachedINTEL +{ + OpSubgroupAvcImeGetBorderReachedINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetBorderReachedINTEL(IdResultType resultType, IdResult result, Id imageSelect, Id payload) + : op(Op::SubgroupAvcImeGetBorderReachedINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->imageSelect = imageSelect; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetBorderReachedINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id imageSelect; + Id payload; +}; + +struct OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL +{ + OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeGetTruncatedSearchIndicationINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetTruncatedSearchIndicationINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL +{ + OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL +{ + OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL +{ + OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcFmeInitializeINTEL +{ + OpSubgroupAvcFmeInitializeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcFmeInitializeINTEL(IdResultType resultType, IdResult result, Id srcCoord, Id motionVectors, Id majorShapes, Id minorShapes, Id direction, Id pixelResolution, Id sadAdjustment) + : op(Op::SubgroupAvcFmeInitializeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcCoord = srcCoord; + this->motionVectors = motionVectors; + this->majorShapes = majorShapes; + this->minorShapes = minorShapes; + this->direction = direction; + this->pixelResolution = pixelResolution; + this->sadAdjustment = sadAdjustment; + } + + static constexpr Op OpCode = Op::SubgroupAvcFmeInitializeINTEL; + static constexpr uint16_t FixedWordSize = 10U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcCoord; + Id motionVectors; + Id majorShapes; + Id minorShapes; + Id direction; + Id pixelResolution; + Id sadAdjustment; +}; + +struct OpSubgroupAvcBmeInitializeINTEL +{ + OpSubgroupAvcBmeInitializeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcBmeInitializeINTEL(IdResultType resultType, IdResult result, Id srcCoord, Id motionVectors, Id majorShapes, Id minorShapes, Id direction, Id pixelResolution, Id bidirectionalWeight, Id sadAdjustment) + : op(Op::SubgroupAvcBmeInitializeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcCoord = srcCoord; + this->motionVectors = motionVectors; + this->majorShapes = majorShapes; + this->minorShapes = minorShapes; + this->direction = direction; + this->pixelResolution = pixelResolution; + this->bidirectionalWeight = bidirectionalWeight; + this->sadAdjustment = sadAdjustment; + } + + static constexpr Op OpCode = Op::SubgroupAvcBmeInitializeINTEL; + static constexpr uint16_t FixedWordSize = 11U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcCoord; + Id motionVectors; + Id majorShapes; + Id minorShapes; + Id direction; + Id pixelResolution; + Id bidirectionalWeight; + Id sadAdjustment; +}; + +struct OpSubgroupAvcRefConvertToMcePayloadINTEL +{ + OpSubgroupAvcRefConvertToMcePayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefConvertToMcePayloadINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcRefConvertToMcePayloadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefConvertToMcePayloadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcRefSetBidirectionalMixDisableINTEL +{ + OpSubgroupAvcRefSetBidirectionalMixDisableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefSetBidirectionalMixDisableINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcRefSetBidirectionalMixDisableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefSetBidirectionalMixDisableINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcRefSetBilinearFilterEnableINTEL +{ + OpSubgroupAvcRefSetBilinearFilterEnableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefSetBilinearFilterEnableINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcRefSetBilinearFilterEnableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefSetBilinearFilterEnableINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL +{ + OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id refImage, Id payload) + : op(Op::SubgroupAvcRefEvaluateWithSingleReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->refImage = refImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefEvaluateWithSingleReferenceINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id refImage; + Id payload; +}; + +struct OpSubgroupAvcRefEvaluateWithDualReferenceINTEL +{ + OpSubgroupAvcRefEvaluateWithDualReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefEvaluateWithDualReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id fwdRefImage, Id bwdRefImage, Id payload) + : op(Op::SubgroupAvcRefEvaluateWithDualReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->fwdRefImage = fwdRefImage; + this->bwdRefImage = bwdRefImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefEvaluateWithDualReferenceINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id fwdRefImage; + Id bwdRefImage; + Id payload; +}; + +struct OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL +{ + OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id packedReferenceIds, Id payload) + : op(Op::SubgroupAvcRefEvaluateWithMultiReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->packedReferenceIds = packedReferenceIds; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefEvaluateWithMultiReferenceINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id packedReferenceIds; + Id payload; +}; + +struct OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL +{ + OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL(IdResultType resultType, IdResult result, Id srcImage, Id packedReferenceIds, Id packedReferenceFieldPolarities, Id payload) + : op(Op::SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->packedReferenceIds = packedReferenceIds; + this->packedReferenceFieldPolarities = packedReferenceFieldPolarities; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id packedReferenceIds; + Id packedReferenceFieldPolarities; + Id payload; +}; + +struct OpSubgroupAvcRefConvertToMceResultINTEL +{ + OpSubgroupAvcRefConvertToMceResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcRefConvertToMceResultINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcRefConvertToMceResultINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcRefConvertToMceResultINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicInitializeINTEL +{ + OpSubgroupAvcSicInitializeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicInitializeINTEL(IdResultType resultType, IdResult result, Id srcCoord) + : op(Op::SubgroupAvcSicInitializeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcCoord = srcCoord; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicInitializeINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcCoord; +}; + +struct OpSubgroupAvcSicConfigureSkcINTEL +{ + OpSubgroupAvcSicConfigureSkcINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicConfigureSkcINTEL(IdResultType resultType, IdResult result, Id skipBlockPartitionType, Id skipMotionVectorMask, Id motionVectors, Id bidirectionalWeight, Id sadAdjustment, Id payload) + : op(Op::SubgroupAvcSicConfigureSkcINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->skipBlockPartitionType = skipBlockPartitionType; + this->skipMotionVectorMask = skipMotionVectorMask; + this->motionVectors = motionVectors; + this->bidirectionalWeight = bidirectionalWeight; + this->sadAdjustment = sadAdjustment; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicConfigureSkcINTEL; + static constexpr uint16_t FixedWordSize = 9U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id skipBlockPartitionType; + Id skipMotionVectorMask; + Id motionVectors; + Id bidirectionalWeight; + Id sadAdjustment; + Id payload; +}; + +struct OpSubgroupAvcSicConfigureIpeLumaINTEL +{ + OpSubgroupAvcSicConfigureIpeLumaINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicConfigureIpeLumaINTEL(IdResultType resultType, IdResult result, Id lumaIntraPartitionMask, Id intraNeighbourAvailabilty, Id leftEdgeLumaPixels, Id upperLeftCornerLumaPixel, Id upperEdgeLumaPixels, Id upperRightEdgeLumaPixels, Id sadAdjustment, Id payload) + : op(Op::SubgroupAvcSicConfigureIpeLumaINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->lumaIntraPartitionMask = lumaIntraPartitionMask; + this->intraNeighbourAvailabilty = intraNeighbourAvailabilty; + this->leftEdgeLumaPixels = leftEdgeLumaPixels; + this->upperLeftCornerLumaPixel = upperLeftCornerLumaPixel; + this->upperEdgeLumaPixels = upperEdgeLumaPixels; + this->upperRightEdgeLumaPixels = upperRightEdgeLumaPixels; + this->sadAdjustment = sadAdjustment; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicConfigureIpeLumaINTEL; + static constexpr uint16_t FixedWordSize = 11U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id lumaIntraPartitionMask; + Id intraNeighbourAvailabilty; + Id leftEdgeLumaPixels; + Id upperLeftCornerLumaPixel; + Id upperEdgeLumaPixels; + Id upperRightEdgeLumaPixels; + Id sadAdjustment; + Id payload; +}; + +struct OpSubgroupAvcSicConfigureIpeLumaChromaINTEL +{ + OpSubgroupAvcSicConfigureIpeLumaChromaINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicConfigureIpeLumaChromaINTEL(IdResultType resultType, IdResult result, Id lumaIntraPartitionMask, Id intraNeighbourAvailabilty, Id leftEdgeLumaPixels, Id upperLeftCornerLumaPixel, Id upperEdgeLumaPixels, Id upperRightEdgeLumaPixels, Id leftEdgeChromaPixels, Id upperLeftCornerChromaPixel, Id upperEdgeChromaPixels, Id sadAdjustment, Id payload) + : op(Op::SubgroupAvcSicConfigureIpeLumaChromaINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->lumaIntraPartitionMask = lumaIntraPartitionMask; + this->intraNeighbourAvailabilty = intraNeighbourAvailabilty; + this->leftEdgeLumaPixels = leftEdgeLumaPixels; + this->upperLeftCornerLumaPixel = upperLeftCornerLumaPixel; + this->upperEdgeLumaPixels = upperEdgeLumaPixels; + this->upperRightEdgeLumaPixels = upperRightEdgeLumaPixels; + this->leftEdgeChromaPixels = leftEdgeChromaPixels; + this->upperLeftCornerChromaPixel = upperLeftCornerChromaPixel; + this->upperEdgeChromaPixels = upperEdgeChromaPixels; + this->sadAdjustment = sadAdjustment; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicConfigureIpeLumaChromaINTEL; + static constexpr uint16_t FixedWordSize = 14U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id lumaIntraPartitionMask; + Id intraNeighbourAvailabilty; + Id leftEdgeLumaPixels; + Id upperLeftCornerLumaPixel; + Id upperEdgeLumaPixels; + Id upperRightEdgeLumaPixels; + Id leftEdgeChromaPixels; + Id upperLeftCornerChromaPixel; + Id upperEdgeChromaPixels; + Id sadAdjustment; + Id payload; +}; + +struct OpSubgroupAvcSicGetMotionVectorMaskINTEL +{ + OpSubgroupAvcSicGetMotionVectorMaskINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetMotionVectorMaskINTEL(IdResultType resultType, IdResult result, Id skipBlockPartitionType, Id direction) + : op(Op::SubgroupAvcSicGetMotionVectorMaskINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->skipBlockPartitionType = skipBlockPartitionType; + this->direction = direction; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetMotionVectorMaskINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id skipBlockPartitionType; + Id direction; +}; + +struct OpSubgroupAvcSicConvertToMcePayloadINTEL +{ + OpSubgroupAvcSicConvertToMcePayloadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicConvertToMcePayloadINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicConvertToMcePayloadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicConvertToMcePayloadINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL +{ + OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL(IdResultType resultType, IdResult result, Id packedShapePenalty, Id payload) + : op(Op::SubgroupAvcSicSetIntraLumaShapePenaltyINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packedShapePenalty = packedShapePenalty; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicSetIntraLumaShapePenaltyINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id packedShapePenalty; + Id payload; +}; + +struct OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL +{ + OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL(IdResultType resultType, IdResult result, Id lumaModePenalty, Id lumaPackedNeighborModes, Id lumaPackedNonDcPenalty, Id payload) + : op(Op::SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->lumaModePenalty = lumaModePenalty; + this->lumaPackedNeighborModes = lumaPackedNeighborModes; + this->lumaPackedNonDcPenalty = lumaPackedNonDcPenalty; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id lumaModePenalty; + Id lumaPackedNeighborModes; + Id lumaPackedNonDcPenalty; + Id payload; +}; + +struct OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL +{ + OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL(IdResultType resultType, IdResult result, Id chromaModeBasePenalty, Id payload) + : op(Op::SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->chromaModeBasePenalty = chromaModeBasePenalty; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id chromaModeBasePenalty; + Id payload; +}; + +struct OpSubgroupAvcSicSetBilinearFilterEnableINTEL +{ + OpSubgroupAvcSicSetBilinearFilterEnableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicSetBilinearFilterEnableINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicSetBilinearFilterEnableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicSetBilinearFilterEnableINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL +{ + OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL(IdResultType resultType, IdResult result, Id packedSadCoefficients, Id payload) + : op(Op::SubgroupAvcSicSetSkcForwardTransformEnableINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->packedSadCoefficients = packedSadCoefficients; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicSetSkcForwardTransformEnableINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id packedSadCoefficients; + Id payload; +}; + +struct OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL +{ + OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL(IdResultType resultType, IdResult result, Id blockBasedSkipType, Id payload) + : op(Op::SubgroupAvcSicSetBlockBasedRawSkipSadINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->blockBasedSkipType = blockBasedSkipType; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicSetBlockBasedRawSkipSadINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id blockBasedSkipType; + Id payload; +}; + +struct OpSubgroupAvcSicEvaluateIpeINTEL +{ + OpSubgroupAvcSicEvaluateIpeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicEvaluateIpeINTEL(IdResultType resultType, IdResult result, Id srcImage, Id payload) + : op(Op::SubgroupAvcSicEvaluateIpeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicEvaluateIpeINTEL; + static constexpr uint16_t FixedWordSize = 5U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id payload; +}; + +struct OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL +{ + OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id refImage, Id payload) + : op(Op::SubgroupAvcSicEvaluateWithSingleReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->refImage = refImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicEvaluateWithSingleReferenceINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id refImage; + Id payload; +}; + +struct OpSubgroupAvcSicEvaluateWithDualReferenceINTEL +{ + OpSubgroupAvcSicEvaluateWithDualReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicEvaluateWithDualReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id fwdRefImage, Id bwdRefImage, Id payload) + : op(Op::SubgroupAvcSicEvaluateWithDualReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->fwdRefImage = fwdRefImage; + this->bwdRefImage = bwdRefImage; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicEvaluateWithDualReferenceINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id fwdRefImage; + Id bwdRefImage; + Id payload; +}; + +struct OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL +{ + OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL(IdResultType resultType, IdResult result, Id srcImage, Id packedReferenceIds, Id payload) + : op(Op::SubgroupAvcSicEvaluateWithMultiReferenceINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->packedReferenceIds = packedReferenceIds; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicEvaluateWithMultiReferenceINTEL; + static constexpr uint16_t FixedWordSize = 6U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id packedReferenceIds; + Id payload; +}; + +struct OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL +{ + OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL(IdResultType resultType, IdResult result, Id srcImage, Id packedReferenceIds, Id packedReferenceFieldPolarities, Id payload) + : op(Op::SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->srcImage = srcImage; + this->packedReferenceIds = packedReferenceIds; + this->packedReferenceFieldPolarities = packedReferenceFieldPolarities; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL; + static constexpr uint16_t FixedWordSize = 7U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id srcImage; + Id packedReferenceIds; + Id packedReferenceFieldPolarities; + Id payload; +}; + +struct OpSubgroupAvcSicConvertToMceResultINTEL +{ + OpSubgroupAvcSicConvertToMceResultINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicConvertToMceResultINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicConvertToMceResultINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicConvertToMceResultINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetIpeLumaShapeINTEL +{ + OpSubgroupAvcSicGetIpeLumaShapeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetIpeLumaShapeINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetIpeLumaShapeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetIpeLumaShapeINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL +{ + OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetBestIpeLumaDistortionINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetBestIpeLumaDistortionINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL +{ + OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetBestIpeChromaDistortionINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetBestIpeChromaDistortionINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetPackedIpeLumaModesINTEL +{ + OpSubgroupAvcSicGetPackedIpeLumaModesINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetPackedIpeLumaModesINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetPackedIpeLumaModesINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetPackedIpeLumaModesINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetIpeChromaModeINTEL +{ + OpSubgroupAvcSicGetIpeChromaModeINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetIpeChromaModeINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetIpeChromaModeINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetIpeChromaModeINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL +{ + OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL +{ + OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +struct OpSubgroupAvcSicGetInterRawSadsINTEL +{ + OpSubgroupAvcSicGetInterRawSadsINTEL(const ConstIter &it) + { + memcpy(this, &(*it), sizeof(*this)); + } + OpSubgroupAvcSicGetInterRawSadsINTEL(IdResultType resultType, IdResult result, Id payload) + : op(Op::SubgroupAvcSicGetInterRawSadsINTEL) + , wordCount(FixedWordSize) + { + this->resultType = resultType; + this->result = result; + this->payload = payload; + } + + static constexpr Op OpCode = Op::SubgroupAvcSicGetInterRawSadsINTEL; + static constexpr uint16_t FixedWordSize = 4U; + Op op; + uint16_t wordCount; + IdResultType resultType; + IdResult result; + Id payload; +}; + +template +inline std::string ParamToStr(const std::function &idName, const T &el) +{ + return ToStr(el); +} + +template<> +std::string ParamToStr(const std::function &idName, const Id &el); +template<> +std::string ParamToStr(const std::function &idName, const rdcstr &el); +template<> +std::string ParamToStr(const std::function &idName, const PairLiteralIntegerIdRef &el); +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefLiteralInteger &el); +template<> +std::string ParamToStr(const std::function &idName, const PairIdRefIdRef &el); + +template<> +std::string ParamToStr(const std::function &idName, const rdcspv::ImageOperandsAndParamDatas &el);template<> +std::string ParamToStr(const std::function &idName, const rdcspv::LoopControlAndParamDatas &el);template<> +std::string ParamToStr(const std::function &idName, const rdcspv::MemoryAccessAndParamDatas &el);template<> +std::string ParamToStr(const std::function &idName, const rdcspv::ExecutionModeAndParamData &el);template<> +std::string ParamToStr(const std::function &idName, const rdcspv::DecorationAndParamData &el); + +template +inline std::string ParamsToStr(const std::function &idName, const rdcarray &ids) +{ + std::string ret = "{"; + for(size_t i=0; i < ids.size(); i++) + { + ret += ParamToStr(idName, ids[i]); + if(i + 1 < ids.size()) + ret += ", "; + } + ret += "}"; + return ret; +} + +struct OpDecoder +{ + OpDecoder(const ConstIter &it); + + static void AddUsedIDs(std::set &usedids, const ConstIter &it); + static std::string Disassemble(const ConstIter &it, const std::function &declName, const std::function &idName, const std::function &constIntVal); + + Op op; + uint16_t wordCount; + Id result; + Id resultType; +}; + +}; // namespace rdcspv