| // Copyright 2025 The Dawn & Tint Authors | |
| // | |
| // Redistribution and use in source and binary forms, with or without | |
| // modification, are permitted provided that the following conditions are met: | |
| // | |
| // 1. Redistributions of source code must retain the above copyright notice, this | |
| // list of conditions and the following disclaimer. | |
| // | |
| // 2. Redistributions in binary form must reproduce the above copyright notice, | |
| // this list of conditions and the following disclaimer in the documentation | |
| // and/or other materials provided with the distribution. | |
| // | |
| // 3. Neither the name of the copyright holder nor the names of its | |
| // contributors may be used to endorse or promote products derived from | |
| // this software without specific prior written permission. | |
| // | |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE | |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR | |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER | |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| //////////////////////////////////////////////////////////////////////////////// | |
| // File generated by 'tools/src/cmd/gen' using the template: | |
| // src/tint/lang/core/enums.cc.tmpl | |
| // | |
| // To regenerate run: './tools/run gen' | |
| // | |
| // Do not modify this file directly | |
| //////////////////////////////////////////////////////////////////////////////// | |
| // clang-format off | |
| #include "src/tint/lang/core/enums.h" | |
| namespace tint::core { | |
| /// ParseAccess parses a Access from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or Access::kUndefined if the string could not be parsed. | |
| Access ParseAccess(std::string_view str) { | |
| if (str == "read") { | |
| return Access::kRead; | |
| } | |
| if (str == "read_write") { | |
| return Access::kReadWrite; | |
| } | |
| if (str == "write") { | |
| return Access::kWrite; | |
| } | |
| return Access::kUndefined; | |
| } | |
| std::string_view ToString(Access value) { | |
| switch (value) { | |
| case Access::kUndefined: | |
| return "undefined"; | |
| case Access::kRead: | |
| return "read"; | |
| case Access::kReadWrite: | |
| return "read_write"; | |
| case Access::kWrite: | |
| return "write"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseAddressSpace parses a AddressSpace from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or AddressSpace::kUndefined if the string could not be parsed. | |
| AddressSpace ParseAddressSpace(std::string_view str) { | |
| if (str == "function") { | |
| return AddressSpace::kFunction; | |
| } | |
| if (str == "immediate") { | |
| return AddressSpace::kImmediate; | |
| } | |
| if (str == "pixel_local") { | |
| return AddressSpace::kPixelLocal; | |
| } | |
| if (str == "private") { | |
| return AddressSpace::kPrivate; | |
| } | |
| if (str == "storage") { | |
| return AddressSpace::kStorage; | |
| } | |
| if (str == "uniform") { | |
| return AddressSpace::kUniform; | |
| } | |
| if (str == "workgroup") { | |
| return AddressSpace::kWorkgroup; | |
| } | |
| return AddressSpace::kUndefined; | |
| } | |
| std::string_view ToString(AddressSpace value) { | |
| switch (value) { | |
| case AddressSpace::kUndefined: | |
| return "undefined"; | |
| case AddressSpace::kIn: | |
| return "__in"; | |
| case AddressSpace::kOut: | |
| return "__out"; | |
| case AddressSpace::kFunction: | |
| return "function"; | |
| case AddressSpace::kHandle: | |
| return "handle"; | |
| case AddressSpace::kImmediate: | |
| return "immediate"; | |
| case AddressSpace::kPixelLocal: | |
| return "pixel_local"; | |
| case AddressSpace::kPrivate: | |
| return "private"; | |
| case AddressSpace::kStorage: | |
| return "storage"; | |
| case AddressSpace::kUniform: | |
| return "uniform"; | |
| case AddressSpace::kWorkgroup: | |
| return "workgroup"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseInterpolationSampling parses a InterpolationSampling from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or InterpolationSampling::kUndefined if the string could not be parsed. | |
| InterpolationSampling ParseInterpolationSampling(std::string_view str) { | |
| if (str == "center") { | |
| return InterpolationSampling::kCenter; | |
| } | |
| if (str == "centroid") { | |
| return InterpolationSampling::kCentroid; | |
| } | |
| if (str == "either") { | |
| return InterpolationSampling::kEither; | |
| } | |
| if (str == "first") { | |
| return InterpolationSampling::kFirst; | |
| } | |
| if (str == "sample") { | |
| return InterpolationSampling::kSample; | |
| } | |
| return InterpolationSampling::kUndefined; | |
| } | |
| std::string_view ToString(InterpolationSampling value) { | |
| switch (value) { | |
| case InterpolationSampling::kUndefined: | |
| return "undefined"; | |
| case InterpolationSampling::kCenter: | |
| return "center"; | |
| case InterpolationSampling::kCentroid: | |
| return "centroid"; | |
| case InterpolationSampling::kEither: | |
| return "either"; | |
| case InterpolationSampling::kFirst: | |
| return "first"; | |
| case InterpolationSampling::kSample: | |
| return "sample"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseInterpolationType parses a InterpolationType from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or InterpolationType::kUndefined if the string could not be parsed. | |
| InterpolationType ParseInterpolationType(std::string_view str) { | |
| if (str == "flat") { | |
| return InterpolationType::kFlat; | |
| } | |
| if (str == "linear") { | |
| return InterpolationType::kLinear; | |
| } | |
| if (str == "perspective") { | |
| return InterpolationType::kPerspective; | |
| } | |
| return InterpolationType::kUndefined; | |
| } | |
| std::string_view ToString(InterpolationType value) { | |
| switch (value) { | |
| case InterpolationType::kUndefined: | |
| return "undefined"; | |
| case InterpolationType::kFlat: | |
| return "flat"; | |
| case InterpolationType::kLinear: | |
| return "linear"; | |
| case InterpolationType::kPerspective: | |
| return "perspective"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseMajorness parses a Majorness from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or Majorness::kUndefined if the string could not be parsed. | |
| Majorness ParseMajorness(std::string_view str) { | |
| if (str == "col_major") { | |
| return Majorness::kColMajor; | |
| } | |
| if (str == "row_major") { | |
| return Majorness::kRowMajor; | |
| } | |
| return Majorness::kUndefined; | |
| } | |
| std::string_view ToString(Majorness value) { | |
| switch (value) { | |
| case Majorness::kUndefined: | |
| return "undefined"; | |
| case Majorness::kColMajor: | |
| return "col_major"; | |
| case Majorness::kRowMajor: | |
| return "row_major"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseSubgroupMatrixKind parses a SubgroupMatrixKind from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or SubgroupMatrixKind::kUndefined if the string could not be parsed. | |
| SubgroupMatrixKind ParseSubgroupMatrixKind(std::string_view str) { | |
| if (str == "left") { | |
| return SubgroupMatrixKind::kLeft; | |
| } | |
| if (str == "result") { | |
| return SubgroupMatrixKind::kResult; | |
| } | |
| if (str == "right") { | |
| return SubgroupMatrixKind::kRight; | |
| } | |
| return SubgroupMatrixKind::kUndefined; | |
| } | |
| std::string_view ToString(SubgroupMatrixKind value) { | |
| switch (value) { | |
| case SubgroupMatrixKind::kUndefined: | |
| return "undefined"; | |
| case SubgroupMatrixKind::kLeft: | |
| return "left"; | |
| case SubgroupMatrixKind::kResult: | |
| return "result"; | |
| case SubgroupMatrixKind::kRight: | |
| return "right"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseTexelFormat parses a TexelFormat from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or TexelFormat::kUndefined if the string could not be parsed. | |
| TexelFormat ParseTexelFormat(std::string_view str) { | |
| if (str == "bgra8unorm") { | |
| return TexelFormat::kBgra8Unorm; | |
| } | |
| if (str == "r16float") { | |
| return TexelFormat::kR16Float; | |
| } | |
| if (str == "r16sint") { | |
| return TexelFormat::kR16Sint; | |
| } | |
| if (str == "r16snorm") { | |
| return TexelFormat::kR16Snorm; | |
| } | |
| if (str == "r16uint") { | |
| return TexelFormat::kR16Uint; | |
| } | |
| if (str == "r16unorm") { | |
| return TexelFormat::kR16Unorm; | |
| } | |
| if (str == "r32float") { | |
| return TexelFormat::kR32Float; | |
| } | |
| if (str == "r32sint") { | |
| return TexelFormat::kR32Sint; | |
| } | |
| if (str == "r32uint") { | |
| return TexelFormat::kR32Uint; | |
| } | |
| if (str == "r8sint") { | |
| return TexelFormat::kR8Sint; | |
| } | |
| if (str == "r8snorm") { | |
| return TexelFormat::kR8Snorm; | |
| } | |
| if (str == "r8uint") { | |
| return TexelFormat::kR8Uint; | |
| } | |
| if (str == "r8unorm") { | |
| return TexelFormat::kR8Unorm; | |
| } | |
| if (str == "rg11b10ufloat") { | |
| return TexelFormat::kRg11B10Ufloat; | |
| } | |
| if (str == "rg16float") { | |
| return TexelFormat::kRg16Float; | |
| } | |
| if (str == "rg16sint") { | |
| return TexelFormat::kRg16Sint; | |
| } | |
| if (str == "rg16snorm") { | |
| return TexelFormat::kRg16Snorm; | |
| } | |
| if (str == "rg16uint") { | |
| return TexelFormat::kRg16Uint; | |
| } | |
| if (str == "rg16unorm") { | |
| return TexelFormat::kRg16Unorm; | |
| } | |
| if (str == "rg32float") { | |
| return TexelFormat::kRg32Float; | |
| } | |
| if (str == "rg32sint") { | |
| return TexelFormat::kRg32Sint; | |
| } | |
| if (str == "rg32uint") { | |
| return TexelFormat::kRg32Uint; | |
| } | |
| if (str == "rg8sint") { | |
| return TexelFormat::kRg8Sint; | |
| } | |
| if (str == "rg8snorm") { | |
| return TexelFormat::kRg8Snorm; | |
| } | |
| if (str == "rg8uint") { | |
| return TexelFormat::kRg8Uint; | |
| } | |
| if (str == "rg8unorm") { | |
| return TexelFormat::kRg8Unorm; | |
| } | |
| if (str == "rgb10a2uint") { | |
| return TexelFormat::kRgb10A2Uint; | |
| } | |
| if (str == "rgb10a2unorm") { | |
| return TexelFormat::kRgb10A2Unorm; | |
| } | |
| if (str == "rgba16float") { | |
| return TexelFormat::kRgba16Float; | |
| } | |
| if (str == "rgba16sint") { | |
| return TexelFormat::kRgba16Sint; | |
| } | |
| if (str == "rgba16snorm") { | |
| return TexelFormat::kRgba16Snorm; | |
| } | |
| if (str == "rgba16uint") { | |
| return TexelFormat::kRgba16Uint; | |
| } | |
| if (str == "rgba16unorm") { | |
| return TexelFormat::kRgba16Unorm; | |
| } | |
| if (str == "rgba32float") { | |
| return TexelFormat::kRgba32Float; | |
| } | |
| if (str == "rgba32sint") { | |
| return TexelFormat::kRgba32Sint; | |
| } | |
| if (str == "rgba32uint") { | |
| return TexelFormat::kRgba32Uint; | |
| } | |
| if (str == "rgba8sint") { | |
| return TexelFormat::kRgba8Sint; | |
| } | |
| if (str == "rgba8snorm") { | |
| return TexelFormat::kRgba8Snorm; | |
| } | |
| if (str == "rgba8uint") { | |
| return TexelFormat::kRgba8Uint; | |
| } | |
| if (str == "rgba8unorm") { | |
| return TexelFormat::kRgba8Unorm; | |
| } | |
| return TexelFormat::kUndefined; | |
| } | |
| std::string_view ToString(TexelFormat value) { | |
| switch (value) { | |
| case TexelFormat::kUndefined: | |
| return "undefined"; | |
| case TexelFormat::kBgra8Unorm: | |
| return "bgra8unorm"; | |
| case TexelFormat::kR16Float: | |
| return "r16float"; | |
| case TexelFormat::kR16Sint: | |
| return "r16sint"; | |
| case TexelFormat::kR16Snorm: | |
| return "r16snorm"; | |
| case TexelFormat::kR16Uint: | |
| return "r16uint"; | |
| case TexelFormat::kR16Unorm: | |
| return "r16unorm"; | |
| case TexelFormat::kR32Float: | |
| return "r32float"; | |
| case TexelFormat::kR32Sint: | |
| return "r32sint"; | |
| case TexelFormat::kR32Uint: | |
| return "r32uint"; | |
| case TexelFormat::kR8Sint: | |
| return "r8sint"; | |
| case TexelFormat::kR8Snorm: | |
| return "r8snorm"; | |
| case TexelFormat::kR8Uint: | |
| return "r8uint"; | |
| case TexelFormat::kR8Unorm: | |
| return "r8unorm"; | |
| case TexelFormat::kRg11B10Ufloat: | |
| return "rg11b10ufloat"; | |
| case TexelFormat::kRg16Float: | |
| return "rg16float"; | |
| case TexelFormat::kRg16Sint: | |
| return "rg16sint"; | |
| case TexelFormat::kRg16Snorm: | |
| return "rg16snorm"; | |
| case TexelFormat::kRg16Uint: | |
| return "rg16uint"; | |
| case TexelFormat::kRg16Unorm: | |
| return "rg16unorm"; | |
| case TexelFormat::kRg32Float: | |
| return "rg32float"; | |
| case TexelFormat::kRg32Sint: | |
| return "rg32sint"; | |
| case TexelFormat::kRg32Uint: | |
| return "rg32uint"; | |
| case TexelFormat::kRg8Sint: | |
| return "rg8sint"; | |
| case TexelFormat::kRg8Snorm: | |
| return "rg8snorm"; | |
| case TexelFormat::kRg8Uint: | |
| return "rg8uint"; | |
| case TexelFormat::kRg8Unorm: | |
| return "rg8unorm"; | |
| case TexelFormat::kRgb10A2Uint: | |
| return "rgb10a2uint"; | |
| case TexelFormat::kRgb10A2Unorm: | |
| return "rgb10a2unorm"; | |
| case TexelFormat::kRgba16Float: | |
| return "rgba16float"; | |
| case TexelFormat::kRgba16Sint: | |
| return "rgba16sint"; | |
| case TexelFormat::kRgba16Snorm: | |
| return "rgba16snorm"; | |
| case TexelFormat::kRgba16Uint: | |
| return "rgba16uint"; | |
| case TexelFormat::kRgba16Unorm: | |
| return "rgba16unorm"; | |
| case TexelFormat::kRgba32Float: | |
| return "rgba32float"; | |
| case TexelFormat::kRgba32Sint: | |
| return "rgba32sint"; | |
| case TexelFormat::kRgba32Uint: | |
| return "rgba32uint"; | |
| case TexelFormat::kRgba8Sint: | |
| return "rgba8sint"; | |
| case TexelFormat::kRgba8Snorm: | |
| return "rgba8snorm"; | |
| case TexelFormat::kRgba8Uint: | |
| return "rgba8uint"; | |
| case TexelFormat::kRgba8Unorm: | |
| return "rgba8unorm"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseBuiltinType parses a BuiltinType from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or BuiltinType::kUndefined if the string could not be parsed. | |
| BuiltinType ParseBuiltinType(std::string_view str) { | |
| if (str == "__atomic_compare_exchange_result_i32") { | |
| return BuiltinType::kAtomicCompareExchangeResultI32; | |
| } | |
| if (str == "__atomic_compare_exchange_result_u32") { | |
| return BuiltinType::kAtomicCompareExchangeResultU32; | |
| } | |
| if (str == "__frexp_result_abstract") { | |
| return BuiltinType::kFrexpResultAbstract; | |
| } | |
| if (str == "__frexp_result_f16") { | |
| return BuiltinType::kFrexpResultF16; | |
| } | |
| if (str == "__frexp_result_f32") { | |
| return BuiltinType::kFrexpResultF32; | |
| } | |
| if (str == "__frexp_result_vec2_abstract") { | |
| return BuiltinType::kFrexpResultVec2Abstract; | |
| } | |
| if (str == "__frexp_result_vec2_f16") { | |
| return BuiltinType::kFrexpResultVec2F16; | |
| } | |
| if (str == "__frexp_result_vec2_f32") { | |
| return BuiltinType::kFrexpResultVec2F32; | |
| } | |
| if (str == "__frexp_result_vec3_abstract") { | |
| return BuiltinType::kFrexpResultVec3Abstract; | |
| } | |
| if (str == "__frexp_result_vec3_f16") { | |
| return BuiltinType::kFrexpResultVec3F16; | |
| } | |
| if (str == "__frexp_result_vec3_f32") { | |
| return BuiltinType::kFrexpResultVec3F32; | |
| } | |
| if (str == "__frexp_result_vec4_abstract") { | |
| return BuiltinType::kFrexpResultVec4Abstract; | |
| } | |
| if (str == "__frexp_result_vec4_f16") { | |
| return BuiltinType::kFrexpResultVec4F16; | |
| } | |
| if (str == "__frexp_result_vec4_f32") { | |
| return BuiltinType::kFrexpResultVec4F32; | |
| } | |
| if (str == "__modf_result_abstract") { | |
| return BuiltinType::kModfResultAbstract; | |
| } | |
| if (str == "__modf_result_f16") { | |
| return BuiltinType::kModfResultF16; | |
| } | |
| if (str == "__modf_result_f32") { | |
| return BuiltinType::kModfResultF32; | |
| } | |
| if (str == "__modf_result_vec2_abstract") { | |
| return BuiltinType::kModfResultVec2Abstract; | |
| } | |
| if (str == "__modf_result_vec2_f16") { | |
| return BuiltinType::kModfResultVec2F16; | |
| } | |
| if (str == "__modf_result_vec2_f32") { | |
| return BuiltinType::kModfResultVec2F32; | |
| } | |
| if (str == "__modf_result_vec3_abstract") { | |
| return BuiltinType::kModfResultVec3Abstract; | |
| } | |
| if (str == "__modf_result_vec3_f16") { | |
| return BuiltinType::kModfResultVec3F16; | |
| } | |
| if (str == "__modf_result_vec3_f32") { | |
| return BuiltinType::kModfResultVec3F32; | |
| } | |
| if (str == "__modf_result_vec4_abstract") { | |
| return BuiltinType::kModfResultVec4Abstract; | |
| } | |
| if (str == "__modf_result_vec4_f16") { | |
| return BuiltinType::kModfResultVec4F16; | |
| } | |
| if (str == "__modf_result_vec4_f32") { | |
| return BuiltinType::kModfResultVec4F32; | |
| } | |
| if (str == "array") { | |
| return BuiltinType::kArray; | |
| } | |
| if (str == "atomic") { | |
| return BuiltinType::kAtomic; | |
| } | |
| if (str == "binding_array") { | |
| return BuiltinType::kBindingArray; | |
| } | |
| if (str == "bool") { | |
| return BuiltinType::kBool; | |
| } | |
| if (str == "buffer") { | |
| return BuiltinType::kBuffer; | |
| } | |
| if (str == "f16") { | |
| return BuiltinType::kF16; | |
| } | |
| if (str == "f32") { | |
| return BuiltinType::kF32; | |
| } | |
| if (str == "i32") { | |
| return BuiltinType::kI32; | |
| } | |
| if (str == "i8") { | |
| return BuiltinType::kI8; | |
| } | |
| if (str == "input_attachment") { | |
| return BuiltinType::kInputAttachment; | |
| } | |
| if (str == "mat2x2") { | |
| return BuiltinType::kMat2X2; | |
| } | |
| if (str == "mat2x2f") { | |
| return BuiltinType::kMat2X2F; | |
| } | |
| if (str == "mat2x2h") { | |
| return BuiltinType::kMat2X2H; | |
| } | |
| if (str == "mat2x3") { | |
| return BuiltinType::kMat2X3; | |
| } | |
| if (str == "mat2x3f") { | |
| return BuiltinType::kMat2X3F; | |
| } | |
| if (str == "mat2x3h") { | |
| return BuiltinType::kMat2X3H; | |
| } | |
| if (str == "mat2x4") { | |
| return BuiltinType::kMat2X4; | |
| } | |
| if (str == "mat2x4f") { | |
| return BuiltinType::kMat2X4F; | |
| } | |
| if (str == "mat2x4h") { | |
| return BuiltinType::kMat2X4H; | |
| } | |
| if (str == "mat3x2") { | |
| return BuiltinType::kMat3X2; | |
| } | |
| if (str == "mat3x2f") { | |
| return BuiltinType::kMat3X2F; | |
| } | |
| if (str == "mat3x2h") { | |
| return BuiltinType::kMat3X2H; | |
| } | |
| if (str == "mat3x3") { | |
| return BuiltinType::kMat3X3; | |
| } | |
| if (str == "mat3x3f") { | |
| return BuiltinType::kMat3X3F; | |
| } | |
| if (str == "mat3x3h") { | |
| return BuiltinType::kMat3X3H; | |
| } | |
| if (str == "mat3x4") { | |
| return BuiltinType::kMat3X4; | |
| } | |
| if (str == "mat3x4f") { | |
| return BuiltinType::kMat3X4F; | |
| } | |
| if (str == "mat3x4h") { | |
| return BuiltinType::kMat3X4H; | |
| } | |
| if (str == "mat4x2") { | |
| return BuiltinType::kMat4X2; | |
| } | |
| if (str == "mat4x2f") { | |
| return BuiltinType::kMat4X2F; | |
| } | |
| if (str == "mat4x2h") { | |
| return BuiltinType::kMat4X2H; | |
| } | |
| if (str == "mat4x3") { | |
| return BuiltinType::kMat4X3; | |
| } | |
| if (str == "mat4x3f") { | |
| return BuiltinType::kMat4X3F; | |
| } | |
| if (str == "mat4x3h") { | |
| return BuiltinType::kMat4X3H; | |
| } | |
| if (str == "mat4x4") { | |
| return BuiltinType::kMat4X4; | |
| } | |
| if (str == "mat4x4f") { | |
| return BuiltinType::kMat4X4F; | |
| } | |
| if (str == "mat4x4h") { | |
| return BuiltinType::kMat4X4H; | |
| } | |
| if (str == "ptr") { | |
| return BuiltinType::kPtr; | |
| } | |
| if (str == "sampler") { | |
| return BuiltinType::kSampler; | |
| } | |
| if (str == "sampler_comparison") { | |
| return BuiltinType::kSamplerComparison; | |
| } | |
| if (str == "subgroup_matrix_left") { | |
| return BuiltinType::kSubgroupMatrixLeft; | |
| } | |
| if (str == "subgroup_matrix_result") { | |
| return BuiltinType::kSubgroupMatrixResult; | |
| } | |
| if (str == "subgroup_matrix_right") { | |
| return BuiltinType::kSubgroupMatrixRight; | |
| } | |
| if (str == "texel_buffer") { | |
| return BuiltinType::kTexelBuffer; | |
| } | |
| if (str == "texture_1d") { | |
| return BuiltinType::kTexture1D; | |
| } | |
| if (str == "texture_2d") { | |
| return BuiltinType::kTexture2D; | |
| } | |
| if (str == "texture_2d_array") { | |
| return BuiltinType::kTexture2DArray; | |
| } | |
| if (str == "texture_3d") { | |
| return BuiltinType::kTexture3D; | |
| } | |
| if (str == "texture_cube") { | |
| return BuiltinType::kTextureCube; | |
| } | |
| if (str == "texture_cube_array") { | |
| return BuiltinType::kTextureCubeArray; | |
| } | |
| if (str == "texture_depth_2d") { | |
| return BuiltinType::kTextureDepth2D; | |
| } | |
| if (str == "texture_depth_2d_array") { | |
| return BuiltinType::kTextureDepth2DArray; | |
| } | |
| if (str == "texture_depth_cube") { | |
| return BuiltinType::kTextureDepthCube; | |
| } | |
| if (str == "texture_depth_cube_array") { | |
| return BuiltinType::kTextureDepthCubeArray; | |
| } | |
| if (str == "texture_depth_multisampled_2d") { | |
| return BuiltinType::kTextureDepthMultisampled2D; | |
| } | |
| if (str == "texture_external") { | |
| return BuiltinType::kTextureExternal; | |
| } | |
| if (str == "texture_multisampled_2d") { | |
| return BuiltinType::kTextureMultisampled2D; | |
| } | |
| if (str == "texture_storage_1d") { | |
| return BuiltinType::kTextureStorage1D; | |
| } | |
| if (str == "texture_storage_2d") { | |
| return BuiltinType::kTextureStorage2D; | |
| } | |
| if (str == "texture_storage_2d_array") { | |
| return BuiltinType::kTextureStorage2DArray; | |
| } | |
| if (str == "texture_storage_3d") { | |
| return BuiltinType::kTextureStorage3D; | |
| } | |
| if (str == "u16") { | |
| return BuiltinType::kU16; | |
| } | |
| if (str == "u32") { | |
| return BuiltinType::kU32; | |
| } | |
| if (str == "u8") { | |
| return BuiltinType::kU8; | |
| } | |
| if (str == "vec2") { | |
| return BuiltinType::kVec2; | |
| } | |
| if (str == "vec2f") { | |
| return BuiltinType::kVec2F; | |
| } | |
| if (str == "vec2h") { | |
| return BuiltinType::kVec2H; | |
| } | |
| if (str == "vec2i") { | |
| return BuiltinType::kVec2I; | |
| } | |
| if (str == "vec2u") { | |
| return BuiltinType::kVec2U; | |
| } | |
| if (str == "vec3") { | |
| return BuiltinType::kVec3; | |
| } | |
| if (str == "vec3f") { | |
| return BuiltinType::kVec3F; | |
| } | |
| if (str == "vec3h") { | |
| return BuiltinType::kVec3H; | |
| } | |
| if (str == "vec3i") { | |
| return BuiltinType::kVec3I; | |
| } | |
| if (str == "vec3u") { | |
| return BuiltinType::kVec3U; | |
| } | |
| if (str == "vec4") { | |
| return BuiltinType::kVec4; | |
| } | |
| if (str == "vec4f") { | |
| return BuiltinType::kVec4F; | |
| } | |
| if (str == "vec4h") { | |
| return BuiltinType::kVec4H; | |
| } | |
| if (str == "vec4i") { | |
| return BuiltinType::kVec4I; | |
| } | |
| if (str == "vec4u") { | |
| return BuiltinType::kVec4U; | |
| } | |
| return BuiltinType::kUndefined; | |
| } | |
| std::string_view ToString(BuiltinType value) { | |
| switch (value) { | |
| case BuiltinType::kUndefined: | |
| return "undefined"; | |
| case BuiltinType::kAtomicCompareExchangeResultI32: | |
| return "__atomic_compare_exchange_result_i32"; | |
| case BuiltinType::kAtomicCompareExchangeResultU32: | |
| return "__atomic_compare_exchange_result_u32"; | |
| case BuiltinType::kFrexpResultAbstract: | |
| return "__frexp_result_abstract"; | |
| case BuiltinType::kFrexpResultF16: | |
| return "__frexp_result_f16"; | |
| case BuiltinType::kFrexpResultF32: | |
| return "__frexp_result_f32"; | |
| case BuiltinType::kFrexpResultVec2Abstract: | |
| return "__frexp_result_vec2_abstract"; | |
| case BuiltinType::kFrexpResultVec2F16: | |
| return "__frexp_result_vec2_f16"; | |
| case BuiltinType::kFrexpResultVec2F32: | |
| return "__frexp_result_vec2_f32"; | |
| case BuiltinType::kFrexpResultVec3Abstract: | |
| return "__frexp_result_vec3_abstract"; | |
| case BuiltinType::kFrexpResultVec3F16: | |
| return "__frexp_result_vec3_f16"; | |
| case BuiltinType::kFrexpResultVec3F32: | |
| return "__frexp_result_vec3_f32"; | |
| case BuiltinType::kFrexpResultVec4Abstract: | |
| return "__frexp_result_vec4_abstract"; | |
| case BuiltinType::kFrexpResultVec4F16: | |
| return "__frexp_result_vec4_f16"; | |
| case BuiltinType::kFrexpResultVec4F32: | |
| return "__frexp_result_vec4_f32"; | |
| case BuiltinType::kModfResultAbstract: | |
| return "__modf_result_abstract"; | |
| case BuiltinType::kModfResultF16: | |
| return "__modf_result_f16"; | |
| case BuiltinType::kModfResultF32: | |
| return "__modf_result_f32"; | |
| case BuiltinType::kModfResultVec2Abstract: | |
| return "__modf_result_vec2_abstract"; | |
| case BuiltinType::kModfResultVec2F16: | |
| return "__modf_result_vec2_f16"; | |
| case BuiltinType::kModfResultVec2F32: | |
| return "__modf_result_vec2_f32"; | |
| case BuiltinType::kModfResultVec3Abstract: | |
| return "__modf_result_vec3_abstract"; | |
| case BuiltinType::kModfResultVec3F16: | |
| return "__modf_result_vec3_f16"; | |
| case BuiltinType::kModfResultVec3F32: | |
| return "__modf_result_vec3_f32"; | |
| case BuiltinType::kModfResultVec4Abstract: | |
| return "__modf_result_vec4_abstract"; | |
| case BuiltinType::kModfResultVec4F16: | |
| return "__modf_result_vec4_f16"; | |
| case BuiltinType::kModfResultVec4F32: | |
| return "__modf_result_vec4_f32"; | |
| case BuiltinType::kArray: | |
| return "array"; | |
| case BuiltinType::kAtomic: | |
| return "atomic"; | |
| case BuiltinType::kBindingArray: | |
| return "binding_array"; | |
| case BuiltinType::kBool: | |
| return "bool"; | |
| case BuiltinType::kBuffer: | |
| return "buffer"; | |
| case BuiltinType::kF16: | |
| return "f16"; | |
| case BuiltinType::kF32: | |
| return "f32"; | |
| case BuiltinType::kI32: | |
| return "i32"; | |
| case BuiltinType::kI8: | |
| return "i8"; | |
| case BuiltinType::kInputAttachment: | |
| return "input_attachment"; | |
| case BuiltinType::kMat2X2: | |
| return "mat2x2"; | |
| case BuiltinType::kMat2X2F: | |
| return "mat2x2f"; | |
| case BuiltinType::kMat2X2H: | |
| return "mat2x2h"; | |
| case BuiltinType::kMat2X3: | |
| return "mat2x3"; | |
| case BuiltinType::kMat2X3F: | |
| return "mat2x3f"; | |
| case BuiltinType::kMat2X3H: | |
| return "mat2x3h"; | |
| case BuiltinType::kMat2X4: | |
| return "mat2x4"; | |
| case BuiltinType::kMat2X4F: | |
| return "mat2x4f"; | |
| case BuiltinType::kMat2X4H: | |
| return "mat2x4h"; | |
| case BuiltinType::kMat3X2: | |
| return "mat3x2"; | |
| case BuiltinType::kMat3X2F: | |
| return "mat3x2f"; | |
| case BuiltinType::kMat3X2H: | |
| return "mat3x2h"; | |
| case BuiltinType::kMat3X3: | |
| return "mat3x3"; | |
| case BuiltinType::kMat3X3F: | |
| return "mat3x3f"; | |
| case BuiltinType::kMat3X3H: | |
| return "mat3x3h"; | |
| case BuiltinType::kMat3X4: | |
| return "mat3x4"; | |
| case BuiltinType::kMat3X4F: | |
| return "mat3x4f"; | |
| case BuiltinType::kMat3X4H: | |
| return "mat3x4h"; | |
| case BuiltinType::kMat4X2: | |
| return "mat4x2"; | |
| case BuiltinType::kMat4X2F: | |
| return "mat4x2f"; | |
| case BuiltinType::kMat4X2H: | |
| return "mat4x2h"; | |
| case BuiltinType::kMat4X3: | |
| return "mat4x3"; | |
| case BuiltinType::kMat4X3F: | |
| return "mat4x3f"; | |
| case BuiltinType::kMat4X3H: | |
| return "mat4x3h"; | |
| case BuiltinType::kMat4X4: | |
| return "mat4x4"; | |
| case BuiltinType::kMat4X4F: | |
| return "mat4x4f"; | |
| case BuiltinType::kMat4X4H: | |
| return "mat4x4h"; | |
| case BuiltinType::kPtr: | |
| return "ptr"; | |
| case BuiltinType::kSampler: | |
| return "sampler"; | |
| case BuiltinType::kSamplerComparison: | |
| return "sampler_comparison"; | |
| case BuiltinType::kSubgroupMatrixLeft: | |
| return "subgroup_matrix_left"; | |
| case BuiltinType::kSubgroupMatrixResult: | |
| return "subgroup_matrix_result"; | |
| case BuiltinType::kSubgroupMatrixRight: | |
| return "subgroup_matrix_right"; | |
| case BuiltinType::kTexelBuffer: | |
| return "texel_buffer"; | |
| case BuiltinType::kTexture1D: | |
| return "texture_1d"; | |
| case BuiltinType::kTexture2D: | |
| return "texture_2d"; | |
| case BuiltinType::kTexture2DArray: | |
| return "texture_2d_array"; | |
| case BuiltinType::kTexture3D: | |
| return "texture_3d"; | |
| case BuiltinType::kTextureCube: | |
| return "texture_cube"; | |
| case BuiltinType::kTextureCubeArray: | |
| return "texture_cube_array"; | |
| case BuiltinType::kTextureDepth2D: | |
| return "texture_depth_2d"; | |
| case BuiltinType::kTextureDepth2DArray: | |
| return "texture_depth_2d_array"; | |
| case BuiltinType::kTextureDepthCube: | |
| return "texture_depth_cube"; | |
| case BuiltinType::kTextureDepthCubeArray: | |
| return "texture_depth_cube_array"; | |
| case BuiltinType::kTextureDepthMultisampled2D: | |
| return "texture_depth_multisampled_2d"; | |
| case BuiltinType::kTextureExternal: | |
| return "texture_external"; | |
| case BuiltinType::kTextureMultisampled2D: | |
| return "texture_multisampled_2d"; | |
| case BuiltinType::kTextureStorage1D: | |
| return "texture_storage_1d"; | |
| case BuiltinType::kTextureStorage2D: | |
| return "texture_storage_2d"; | |
| case BuiltinType::kTextureStorage2DArray: | |
| return "texture_storage_2d_array"; | |
| case BuiltinType::kTextureStorage3D: | |
| return "texture_storage_3d"; | |
| case BuiltinType::kU16: | |
| return "u16"; | |
| case BuiltinType::kU32: | |
| return "u32"; | |
| case BuiltinType::kU8: | |
| return "u8"; | |
| case BuiltinType::kVec2: | |
| return "vec2"; | |
| case BuiltinType::kVec2F: | |
| return "vec2f"; | |
| case BuiltinType::kVec2H: | |
| return "vec2h"; | |
| case BuiltinType::kVec2I: | |
| return "vec2i"; | |
| case BuiltinType::kVec2U: | |
| return "vec2u"; | |
| case BuiltinType::kVec3: | |
| return "vec3"; | |
| case BuiltinType::kVec3F: | |
| return "vec3f"; | |
| case BuiltinType::kVec3H: | |
| return "vec3h"; | |
| case BuiltinType::kVec3I: | |
| return "vec3i"; | |
| case BuiltinType::kVec3U: | |
| return "vec3u"; | |
| case BuiltinType::kVec4: | |
| return "vec4"; | |
| case BuiltinType::kVec4F: | |
| return "vec4f"; | |
| case BuiltinType::kVec4H: | |
| return "vec4h"; | |
| case BuiltinType::kVec4I: | |
| return "vec4i"; | |
| case BuiltinType::kVec4U: | |
| return "vec4u"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseBuiltinValue parses a BuiltinValue from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or BuiltinValue::kUndefined if the string could not be parsed. | |
| BuiltinValue ParseBuiltinValue(std::string_view str) { | |
| if (str == "barycentric_coord") { | |
| return BuiltinValue::kBarycentricCoord; | |
| } | |
| if (str == "clip_distances") { | |
| return BuiltinValue::kClipDistances; | |
| } | |
| if (str == "frag_depth") { | |
| return BuiltinValue::kFragDepth; | |
| } | |
| if (str == "front_facing") { | |
| return BuiltinValue::kFrontFacing; | |
| } | |
| if (str == "global_invocation_id") { | |
| return BuiltinValue::kGlobalInvocationId; | |
| } | |
| if (str == "global_invocation_index") { | |
| return BuiltinValue::kGlobalInvocationIndex; | |
| } | |
| if (str == "instance_index") { | |
| return BuiltinValue::kInstanceIndex; | |
| } | |
| if (str == "local_invocation_id") { | |
| return BuiltinValue::kLocalInvocationId; | |
| } | |
| if (str == "local_invocation_index") { | |
| return BuiltinValue::kLocalInvocationIndex; | |
| } | |
| if (str == "num_subgroups") { | |
| return BuiltinValue::kNumSubgroups; | |
| } | |
| if (str == "num_workgroups") { | |
| return BuiltinValue::kNumWorkgroups; | |
| } | |
| if (str == "position") { | |
| return BuiltinValue::kPosition; | |
| } | |
| if (str == "primitive_index") { | |
| return BuiltinValue::kPrimitiveIndex; | |
| } | |
| if (str == "sample_index") { | |
| return BuiltinValue::kSampleIndex; | |
| } | |
| if (str == "sample_mask") { | |
| return BuiltinValue::kSampleMask; | |
| } | |
| if (str == "subgroup_id") { | |
| return BuiltinValue::kSubgroupId; | |
| } | |
| if (str == "subgroup_invocation_id") { | |
| return BuiltinValue::kSubgroupInvocationId; | |
| } | |
| if (str == "subgroup_size") { | |
| return BuiltinValue::kSubgroupSize; | |
| } | |
| if (str == "vertex_index") { | |
| return BuiltinValue::kVertexIndex; | |
| } | |
| if (str == "workgroup_id") { | |
| return BuiltinValue::kWorkgroupId; | |
| } | |
| if (str == "workgroup_index") { | |
| return BuiltinValue::kWorkgroupIndex; | |
| } | |
| return BuiltinValue::kUndefined; | |
| } | |
| std::string_view ToString(BuiltinValue value) { | |
| switch (value) { | |
| case BuiltinValue::kUndefined: | |
| return "undefined"; | |
| case BuiltinValue::kCullDistance: | |
| return "__cull_distance"; | |
| case BuiltinValue::kPointSize: | |
| return "__point_size"; | |
| case BuiltinValue::kBarycentricCoord: | |
| return "barycentric_coord"; | |
| case BuiltinValue::kClipDistances: | |
| return "clip_distances"; | |
| case BuiltinValue::kFragDepth: | |
| return "frag_depth"; | |
| case BuiltinValue::kFrontFacing: | |
| return "front_facing"; | |
| case BuiltinValue::kGlobalInvocationId: | |
| return "global_invocation_id"; | |
| case BuiltinValue::kGlobalInvocationIndex: | |
| return "global_invocation_index"; | |
| case BuiltinValue::kInstanceIndex: | |
| return "instance_index"; | |
| case BuiltinValue::kLocalInvocationId: | |
| return "local_invocation_id"; | |
| case BuiltinValue::kLocalInvocationIndex: | |
| return "local_invocation_index"; | |
| case BuiltinValue::kNumSubgroups: | |
| return "num_subgroups"; | |
| case BuiltinValue::kNumWorkgroups: | |
| return "num_workgroups"; | |
| case BuiltinValue::kPosition: | |
| return "position"; | |
| case BuiltinValue::kPrimitiveIndex: | |
| return "primitive_index"; | |
| case BuiltinValue::kSampleIndex: | |
| return "sample_index"; | |
| case BuiltinValue::kSampleMask: | |
| return "sample_mask"; | |
| case BuiltinValue::kSubgroupId: | |
| return "subgroup_id"; | |
| case BuiltinValue::kSubgroupInvocationId: | |
| return "subgroup_invocation_id"; | |
| case BuiltinValue::kSubgroupSize: | |
| return "subgroup_size"; | |
| case BuiltinValue::kVertexIndex: | |
| return "vertex_index"; | |
| case BuiltinValue::kWorkgroupId: | |
| return "workgroup_id"; | |
| case BuiltinValue::kWorkgroupIndex: | |
| return "workgroup_index"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseBuiltinDepthMode parses a BuiltinDepthMode from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or BuiltinDepthMode::kUndefined if the string could not be parsed. | |
| BuiltinDepthMode ParseBuiltinDepthMode(std::string_view str) { | |
| if (str == "greater") { | |
| return BuiltinDepthMode::kGreater; | |
| } | |
| if (str == "less") { | |
| return BuiltinDepthMode::kLess; | |
| } | |
| return BuiltinDepthMode::kUndefined; | |
| } | |
| std::string_view ToString(BuiltinDepthMode value) { | |
| switch (value) { | |
| case BuiltinDepthMode::kUndefined: | |
| return "undefined"; | |
| case BuiltinDepthMode::kGreater: | |
| return "greater"; | |
| case BuiltinDepthMode::kLess: | |
| return "less"; | |
| } | |
| return "<unknown>"; | |
| } | |
| /// ParseAttribute parses a Attribute from a string. | |
| /// @param str the string to parse | |
| /// @returns the parsed enum, or Attribute::kUndefined if the string could not be parsed. | |
| Attribute ParseAttribute(std::string_view str) { | |
| if (str == "align") { | |
| return Attribute::kAlign; | |
| } | |
| if (str == "binding") { | |
| return Attribute::kBinding; | |
| } | |
| if (str == "blend_src") { | |
| return Attribute::kBlendSrc; | |
| } | |
| if (str == "builtin") { | |
| return Attribute::kBuiltin; | |
| } | |
| if (str == "color") { | |
| return Attribute::kColor; | |
| } | |
| if (str == "compute") { | |
| return Attribute::kCompute; | |
| } | |
| if (str == "diagnostic") { | |
| return Attribute::kDiagnostic; | |
| } | |
| if (str == "fragment") { | |
| return Attribute::kFragment; | |
| } | |
| if (str == "group") { | |
| return Attribute::kGroup; | |
| } | |
| if (str == "id") { | |
| return Attribute::kId; | |
| } | |
| if (str == "input_attachment_index") { | |
| return Attribute::kInputAttachmentIndex; | |
| } | |
| if (str == "interpolate") { | |
| return Attribute::kInterpolate; | |
| } | |
| if (str == "invariant") { | |
| return Attribute::kInvariant; | |
| } | |
| if (str == "location") { | |
| return Attribute::kLocation; | |
| } | |
| if (str == "must_use") { | |
| return Attribute::kMustUse; | |
| } | |
| if (str == "size") { | |
| return Attribute::kSize; | |
| } | |
| if (str == "subgroup_size") { | |
| return Attribute::kSubgroupSize; | |
| } | |
| if (str == "vertex") { | |
| return Attribute::kVertex; | |
| } | |
| if (str == "workgroup_size") { | |
| return Attribute::kWorkgroupSize; | |
| } | |
| return Attribute::kUndefined; | |
| } | |
| std::string_view ToString(Attribute value) { | |
| switch (value) { | |
| case Attribute::kUndefined: | |
| return "undefined"; | |
| case Attribute::kAlign: | |
| return "align"; | |
| case Attribute::kBinding: | |
| return "binding"; | |
| case Attribute::kBlendSrc: | |
| return "blend_src"; | |
| case Attribute::kBuiltin: | |
| return "builtin"; | |
| case Attribute::kColor: | |
| return "color"; | |
| case Attribute::kCompute: | |
| return "compute"; | |
| case Attribute::kDiagnostic: | |
| return "diagnostic"; | |
| case Attribute::kFragment: | |
| return "fragment"; | |
| case Attribute::kGroup: | |
| return "group"; | |
| case Attribute::kId: | |
| return "id"; | |
| case Attribute::kInputAttachmentIndex: | |
| return "input_attachment_index"; | |
| case Attribute::kInterpolate: | |
| return "interpolate"; | |
| case Attribute::kInvariant: | |
| return "invariant"; | |
| case Attribute::kLocation: | |
| return "location"; | |
| case Attribute::kMustUse: | |
| return "must_use"; | |
| case Attribute::kSize: | |
| return "size"; | |
| case Attribute::kSubgroupSize: | |
| return "subgroup_size"; | |
| case Attribute::kVertex: | |
| return "vertex"; | |
| case Attribute::kWorkgroupSize: | |
| return "workgroup_size"; | |
| } | |
| return "<unknown>"; | |
| } | |
| std::string_view ToString(ParameterUsage usage) { | |
| switch (usage) { | |
| case ParameterUsage::kColMajor: | |
| return "col_major"; | |
| case ParameterUsage::kNone: | |
| return "none"; | |
| case ParameterUsage::kArrayIndex: | |
| return "array_index"; | |
| case ParameterUsage::kBase: | |
| return "base"; | |
| case ParameterUsage::kBias: | |
| return "bias"; | |
| case ParameterUsage::kBits: | |
| return "bits"; | |
| case ParameterUsage::kCompareValue: | |
| return "compare_value"; | |
| case ParameterUsage::kComponent: | |
| return "component"; | |
| case ParameterUsage::kConstOffset: | |
| return "const_offset"; | |
| case ParameterUsage::kCoords: | |
| return "coords"; | |
| case ParameterUsage::kCount: | |
| return "count"; | |
| case ParameterUsage::kDdx: | |
| return "ddx"; | |
| case ParameterUsage::kDdy: | |
| return "ddy"; | |
| case ParameterUsage::kDelta: | |
| return "delta"; | |
| case ParameterUsage::kDepth: | |
| return "depth"; | |
| case ParameterUsage::kDepthRef: | |
| return "depth_ref"; | |
| case ParameterUsage::kDir: | |
| return "dir"; | |
| case ParameterUsage::kDref: | |
| return "dref"; | |
| case ParameterUsage::kE: | |
| return "e"; | |
| case ParameterUsage::kElements: | |
| return "elements"; | |
| case ParameterUsage::kExp: | |
| return "exp"; | |
| case ParameterUsage::kExtents: | |
| return "extents"; | |
| case ParameterUsage::kGroupOperation: | |
| return "group_operation"; | |
| case ParameterUsage::kHeight: | |
| return "height"; | |
| case ParameterUsage::kI: | |
| return "i"; | |
| case ParameterUsage::kId: | |
| return "id"; | |
| case ParameterUsage::kImage: | |
| return "image"; | |
| case ParameterUsage::kImageOperands: | |
| return "image_operands"; | |
| case ParameterUsage::kIndex: | |
| return "index"; | |
| case ParameterUsage::kInputAttachment: | |
| return "input_attachment"; | |
| case ParameterUsage::kInsert: | |
| return "insert"; | |
| case ParameterUsage::kLevel: | |
| return "level"; | |
| case ParameterUsage::kLocation: | |
| return "location"; | |
| case ParameterUsage::kLod: | |
| return "lod"; | |
| case ParameterUsage::kM: | |
| return "m"; | |
| case ParameterUsage::kMask: | |
| return "mask"; | |
| case ParameterUsage::kNumLevels: | |
| return "num_levels"; | |
| case ParameterUsage::kOffset: | |
| return "offset"; | |
| case ParameterUsage::kOriginalValue: | |
| return "original_value"; | |
| case ParameterUsage::kRefz: | |
| return "refz"; | |
| case ParameterUsage::kResult: | |
| return "result"; | |
| case ParameterUsage::kS: | |
| return "s"; | |
| case ParameterUsage::kSample: | |
| return "sample"; | |
| case ParameterUsage::kSampleIndex: | |
| return "sample_index"; | |
| case ParameterUsage::kSampler: | |
| return "sampler"; | |
| case ParameterUsage::kSamples: | |
| return "samples"; | |
| case ParameterUsage::kScope: | |
| return "scope"; | |
| case ParameterUsage::kSourceLaneIndex: | |
| return "sourceLaneIndex"; | |
| case ParameterUsage::kStride: | |
| return "stride"; | |
| case ParameterUsage::kTexel: | |
| return "texel"; | |
| case ParameterUsage::kTexture: | |
| return "texture"; | |
| case ParameterUsage::kValue: | |
| return "value"; | |
| case ParameterUsage::kW: | |
| return "w"; | |
| case ParameterUsage::kWidth: | |
| return "width"; | |
| case ParameterUsage::kX: | |
| return "x"; | |
| case ParameterUsage::kXy: | |
| return "xy"; | |
| case ParameterUsage::kXyz: | |
| return "xyz"; | |
| case ParameterUsage::kY: | |
| return "y"; | |
| case ParameterUsage::kYz: | |
| return "yz"; | |
| case ParameterUsage::kZ: | |
| return "z"; | |
| case ParameterUsage::kZw: | |
| return "zw"; | |
| case ParameterUsage::kZyw: | |
| return "zyw"; | |
| } | |
| return "<unknown>"; | |
| } | |
| BuiltinFn ParseBuiltinFn(std::string_view name) { | |
| if (name == "abs") { | |
| return BuiltinFn::kAbs; | |
| } | |
| if (name == "acos") { | |
| return BuiltinFn::kAcos; | |
| } | |
| if (name == "acosh") { | |
| return BuiltinFn::kAcosh; | |
| } | |
| if (name == "all") { | |
| return BuiltinFn::kAll; | |
| } | |
| if (name == "any") { | |
| return BuiltinFn::kAny; | |
| } | |
| if (name == "arrayLength") { | |
| return BuiltinFn::kArrayLength; | |
| } | |
| if (name == "asin") { | |
| return BuiltinFn::kAsin; | |
| } | |
| if (name == "asinh") { | |
| return BuiltinFn::kAsinh; | |
| } | |
| if (name == "atan") { | |
| return BuiltinFn::kAtan; | |
| } | |
| if (name == "atan2") { | |
| return BuiltinFn::kAtan2; | |
| } | |
| if (name == "atanh") { | |
| return BuiltinFn::kAtanh; | |
| } | |
| if (name == "bitcast") { | |
| return BuiltinFn::kBitcast; | |
| } | |
| if (name == "ceil") { | |
| return BuiltinFn::kCeil; | |
| } | |
| if (name == "clamp") { | |
| return BuiltinFn::kClamp; | |
| } | |
| if (name == "cos") { | |
| return BuiltinFn::kCos; | |
| } | |
| if (name == "cosh") { | |
| return BuiltinFn::kCosh; | |
| } | |
| if (name == "countLeadingZeros") { | |
| return BuiltinFn::kCountLeadingZeros; | |
| } | |
| if (name == "countOneBits") { | |
| return BuiltinFn::kCountOneBits; | |
| } | |
| if (name == "countTrailingZeros") { | |
| return BuiltinFn::kCountTrailingZeros; | |
| } | |
| if (name == "cross") { | |
| return BuiltinFn::kCross; | |
| } | |
| if (name == "degrees") { | |
| return BuiltinFn::kDegrees; | |
| } | |
| if (name == "determinant") { | |
| return BuiltinFn::kDeterminant; | |
| } | |
| if (name == "distance") { | |
| return BuiltinFn::kDistance; | |
| } | |
| if (name == "dot") { | |
| return BuiltinFn::kDot; | |
| } | |
| if (name == "dot4I8Packed") { | |
| return BuiltinFn::kDot4I8Packed; | |
| } | |
| if (name == "dot4U8Packed") { | |
| return BuiltinFn::kDot4U8Packed; | |
| } | |
| if (name == "dpdx") { | |
| return BuiltinFn::kDpdx; | |
| } | |
| if (name == "dpdxCoarse") { | |
| return BuiltinFn::kDpdxCoarse; | |
| } | |
| if (name == "dpdxFine") { | |
| return BuiltinFn::kDpdxFine; | |
| } | |
| if (name == "dpdy") { | |
| return BuiltinFn::kDpdy; | |
| } | |
| if (name == "dpdyCoarse") { | |
| return BuiltinFn::kDpdyCoarse; | |
| } | |
| if (name == "dpdyFine") { | |
| return BuiltinFn::kDpdyFine; | |
| } | |
| if (name == "exp") { | |
| return BuiltinFn::kExp; | |
| } | |
| if (name == "exp2") { | |
| return BuiltinFn::kExp2; | |
| } | |
| if (name == "extractBits") { | |
| return BuiltinFn::kExtractBits; | |
| } | |
| if (name == "faceForward") { | |
| return BuiltinFn::kFaceForward; | |
| } | |
| if (name == "firstLeadingBit") { | |
| return BuiltinFn::kFirstLeadingBit; | |
| } | |
| if (name == "firstTrailingBit") { | |
| return BuiltinFn::kFirstTrailingBit; | |
| } | |
| if (name == "floor") { | |
| return BuiltinFn::kFloor; | |
| } | |
| if (name == "fma") { | |
| return BuiltinFn::kFma; | |
| } | |
| if (name == "fract") { | |
| return BuiltinFn::kFract; | |
| } | |
| if (name == "frexp") { | |
| return BuiltinFn::kFrexp; | |
| } | |
| if (name == "fwidth") { | |
| return BuiltinFn::kFwidth; | |
| } | |
| if (name == "fwidthCoarse") { | |
| return BuiltinFn::kFwidthCoarse; | |
| } | |
| if (name == "fwidthFine") { | |
| return BuiltinFn::kFwidthFine; | |
| } | |
| if (name == "insertBits") { | |
| return BuiltinFn::kInsertBits; | |
| } | |
| if (name == "inverseSqrt") { | |
| return BuiltinFn::kInverseSqrt; | |
| } | |
| if (name == "ldexp") { | |
| return BuiltinFn::kLdexp; | |
| } | |
| if (name == "length") { | |
| return BuiltinFn::kLength; | |
| } | |
| if (name == "log") { | |
| return BuiltinFn::kLog; | |
| } | |
| if (name == "log2") { | |
| return BuiltinFn::kLog2; | |
| } | |
| if (name == "max") { | |
| return BuiltinFn::kMax; | |
| } | |
| if (name == "min") { | |
| return BuiltinFn::kMin; | |
| } | |
| if (name == "mix") { | |
| return BuiltinFn::kMix; | |
| } | |
| if (name == "modf") { | |
| return BuiltinFn::kModf; | |
| } | |
| if (name == "normalize") { | |
| return BuiltinFn::kNormalize; | |
| } | |
| if (name == "pack2x16float") { | |
| return BuiltinFn::kPack2X16Float; | |
| } | |
| if (name == "pack2x16snorm") { | |
| return BuiltinFn::kPack2X16Snorm; | |
| } | |
| if (name == "pack2x16unorm") { | |
| return BuiltinFn::kPack2X16Unorm; | |
| } | |
| if (name == "pack4x8snorm") { | |
| return BuiltinFn::kPack4X8Snorm; | |
| } | |
| if (name == "pack4x8unorm") { | |
| return BuiltinFn::kPack4X8Unorm; | |
| } | |
| if (name == "pack4xI8") { | |
| return BuiltinFn::kPack4XI8; | |
| } | |
| if (name == "pack4xU8") { | |
| return BuiltinFn::kPack4XU8; | |
| } | |
| if (name == "pack4xI8Clamp") { | |
| return BuiltinFn::kPack4XI8Clamp; | |
| } | |
| if (name == "pack4xU8Clamp") { | |
| return BuiltinFn::kPack4XU8Clamp; | |
| } | |
| if (name == "pow") { | |
| return BuiltinFn::kPow; | |
| } | |
| if (name == "quantizeToF16") { | |
| return BuiltinFn::kQuantizeToF16; | |
| } | |
| if (name == "radians") { | |
| return BuiltinFn::kRadians; | |
| } | |
| if (name == "reflect") { | |
| return BuiltinFn::kReflect; | |
| } | |
| if (name == "refract") { | |
| return BuiltinFn::kRefract; | |
| } | |
| if (name == "reverseBits") { | |
| return BuiltinFn::kReverseBits; | |
| } | |
| if (name == "round") { | |
| return BuiltinFn::kRound; | |
| } | |
| if (name == "saturate") { | |
| return BuiltinFn::kSaturate; | |
| } | |
| if (name == "select") { | |
| return BuiltinFn::kSelect; | |
| } | |
| if (name == "sign") { | |
| return BuiltinFn::kSign; | |
| } | |
| if (name == "sin") { | |
| return BuiltinFn::kSin; | |
| } | |
| if (name == "sinh") { | |
| return BuiltinFn::kSinh; | |
| } | |
| if (name == "smoothstep") { | |
| return BuiltinFn::kSmoothstep; | |
| } | |
| if (name == "sqrt") { | |
| return BuiltinFn::kSqrt; | |
| } | |
| if (name == "step") { | |
| return BuiltinFn::kStep; | |
| } | |
| if (name == "tan") { | |
| return BuiltinFn::kTan; | |
| } | |
| if (name == "tanh") { | |
| return BuiltinFn::kTanh; | |
| } | |
| if (name == "transpose") { | |
| return BuiltinFn::kTranspose; | |
| } | |
| if (name == "trunc") { | |
| return BuiltinFn::kTrunc; | |
| } | |
| if (name == "unpack2x16float") { | |
| return BuiltinFn::kUnpack2X16Float; | |
| } | |
| if (name == "unpack2x16snorm") { | |
| return BuiltinFn::kUnpack2X16Snorm; | |
| } | |
| if (name == "unpack2x16unorm") { | |
| return BuiltinFn::kUnpack2X16Unorm; | |
| } | |
| if (name == "unpack4x8snorm") { | |
| return BuiltinFn::kUnpack4X8Snorm; | |
| } | |
| if (name == "unpack4x8unorm") { | |
| return BuiltinFn::kUnpack4X8Unorm; | |
| } | |
| if (name == "unpack4xI8") { | |
| return BuiltinFn::kUnpack4XI8; | |
| } | |
| if (name == "unpack4xU8") { | |
| return BuiltinFn::kUnpack4XU8; | |
| } | |
| if (name == "addSat") { | |
| return BuiltinFn::kAddSat; | |
| } | |
| if (name == "mulSat") { | |
| return BuiltinFn::kMulSat; | |
| } | |
| if (name == "storageBarrier") { | |
| return BuiltinFn::kStorageBarrier; | |
| } | |
| if (name == "workgroupBarrier") { | |
| return BuiltinFn::kWorkgroupBarrier; | |
| } | |
| if (name == "textureBarrier") { | |
| return BuiltinFn::kTextureBarrier; | |
| } | |
| if (name == "textureDimensions") { | |
| return BuiltinFn::kTextureDimensions; | |
| } | |
| if (name == "textureGather") { | |
| return BuiltinFn::kTextureGather; | |
| } | |
| if (name == "textureGatherCompare") { | |
| return BuiltinFn::kTextureGatherCompare; | |
| } | |
| if (name == "textureNumLayers") { | |
| return BuiltinFn::kTextureNumLayers; | |
| } | |
| if (name == "textureNumLevels") { | |
| return BuiltinFn::kTextureNumLevels; | |
| } | |
| if (name == "textureNumSamples") { | |
| return BuiltinFn::kTextureNumSamples; | |
| } | |
| if (name == "textureSample") { | |
| return BuiltinFn::kTextureSample; | |
| } | |
| if (name == "textureSampleBias") { | |
| return BuiltinFn::kTextureSampleBias; | |
| } | |
| if (name == "textureSampleCompare") { | |
| return BuiltinFn::kTextureSampleCompare; | |
| } | |
| if (name == "textureSampleCompareLevel") { | |
| return BuiltinFn::kTextureSampleCompareLevel; | |
| } | |
| if (name == "textureSampleGrad") { | |
| return BuiltinFn::kTextureSampleGrad; | |
| } | |
| if (name == "textureSampleLevel") { | |
| return BuiltinFn::kTextureSampleLevel; | |
| } | |
| if (name == "textureSampleBaseClampToEdge") { | |
| return BuiltinFn::kTextureSampleBaseClampToEdge; | |
| } | |
| if (name == "textureStore") { | |
| return BuiltinFn::kTextureStore; | |
| } | |
| if (name == "textureLoad") { | |
| return BuiltinFn::kTextureLoad; | |
| } | |
| if (name == "inputAttachmentLoad") { | |
| return BuiltinFn::kInputAttachmentLoad; | |
| } | |
| if (name == "atomicLoad") { | |
| return BuiltinFn::kAtomicLoad; | |
| } | |
| if (name == "atomicStore") { | |
| return BuiltinFn::kAtomicStore; | |
| } | |
| if (name == "atomicAdd") { | |
| return BuiltinFn::kAtomicAdd; | |
| } | |
| if (name == "atomicSub") { | |
| return BuiltinFn::kAtomicSub; | |
| } | |
| if (name == "atomicMax") { | |
| return BuiltinFn::kAtomicMax; | |
| } | |
| if (name == "atomicMin") { | |
| return BuiltinFn::kAtomicMin; | |
| } | |
| if (name == "atomicAnd") { | |
| return BuiltinFn::kAtomicAnd; | |
| } | |
| if (name == "atomicOr") { | |
| return BuiltinFn::kAtomicOr; | |
| } | |
| if (name == "atomicXor") { | |
| return BuiltinFn::kAtomicXor; | |
| } | |
| if (name == "atomicExchange") { | |
| return BuiltinFn::kAtomicExchange; | |
| } | |
| if (name == "atomicCompareExchangeWeak") { | |
| return BuiltinFn::kAtomicCompareExchangeWeak; | |
| } | |
| if (name == "atomicStoreMax") { | |
| return BuiltinFn::kAtomicStoreMax; | |
| } | |
| if (name == "atomicStoreMin") { | |
| return BuiltinFn::kAtomicStoreMin; | |
| } | |
| if (name == "subgroupBallot") { | |
| return BuiltinFn::kSubgroupBallot; | |
| } | |
| if (name == "subgroupElect") { | |
| return BuiltinFn::kSubgroupElect; | |
| } | |
| if (name == "subgroupBroadcast") { | |
| return BuiltinFn::kSubgroupBroadcast; | |
| } | |
| if (name == "subgroupBroadcastFirst") { | |
| return BuiltinFn::kSubgroupBroadcastFirst; | |
| } | |
| if (name == "subgroupShuffle") { | |
| return BuiltinFn::kSubgroupShuffle; | |
| } | |
| if (name == "subgroupShuffleXor") { | |
| return BuiltinFn::kSubgroupShuffleXor; | |
| } | |
| if (name == "subgroupShuffleUp") { | |
| return BuiltinFn::kSubgroupShuffleUp; | |
| } | |
| if (name == "subgroupShuffleDown") { | |
| return BuiltinFn::kSubgroupShuffleDown; | |
| } | |
| if (name == "subgroupAdd") { | |
| return BuiltinFn::kSubgroupAdd; | |
| } | |
| if (name == "subgroupInclusiveAdd") { | |
| return BuiltinFn::kSubgroupInclusiveAdd; | |
| } | |
| if (name == "subgroupExclusiveAdd") { | |
| return BuiltinFn::kSubgroupExclusiveAdd; | |
| } | |
| if (name == "subgroupMul") { | |
| return BuiltinFn::kSubgroupMul; | |
| } | |
| if (name == "subgroupInclusiveMul") { | |
| return BuiltinFn::kSubgroupInclusiveMul; | |
| } | |
| if (name == "subgroupExclusiveMul") { | |
| return BuiltinFn::kSubgroupExclusiveMul; | |
| } | |
| if (name == "subgroupAnd") { | |
| return BuiltinFn::kSubgroupAnd; | |
| } | |
| if (name == "subgroupOr") { | |
| return BuiltinFn::kSubgroupOr; | |
| } | |
| if (name == "subgroupXor") { | |
| return BuiltinFn::kSubgroupXor; | |
| } | |
| if (name == "subgroupMin") { | |
| return BuiltinFn::kSubgroupMin; | |
| } | |
| if (name == "subgroupMax") { | |
| return BuiltinFn::kSubgroupMax; | |
| } | |
| if (name == "subgroupAll") { | |
| return BuiltinFn::kSubgroupAll; | |
| } | |
| if (name == "subgroupAny") { | |
| return BuiltinFn::kSubgroupAny; | |
| } | |
| if (name == "quadBroadcast") { | |
| return BuiltinFn::kQuadBroadcast; | |
| } | |
| if (name == "quadSwapX") { | |
| return BuiltinFn::kQuadSwapX; | |
| } | |
| if (name == "quadSwapY") { | |
| return BuiltinFn::kQuadSwapY; | |
| } | |
| if (name == "quadSwapDiagonal") { | |
| return BuiltinFn::kQuadSwapDiagonal; | |
| } | |
| if (name == "subgroupMatrixLoad") { | |
| return BuiltinFn::kSubgroupMatrixLoad; | |
| } | |
| if (name == "subgroupMatrixStore") { | |
| return BuiltinFn::kSubgroupMatrixStore; | |
| } | |
| if (name == "subgroupMatrixMultiply") { | |
| return BuiltinFn::kSubgroupMatrixMultiply; | |
| } | |
| if (name == "subgroupMatrixMultiplyAccumulate") { | |
| return BuiltinFn::kSubgroupMatrixMultiplyAccumulate; | |
| } | |
| if (name == "subgroupMatrixScalarAdd") { | |
| return BuiltinFn::kSubgroupMatrixScalarAdd; | |
| } | |
| if (name == "subgroupMatrixScalarSubtract") { | |
| return BuiltinFn::kSubgroupMatrixScalarSubtract; | |
| } | |
| if (name == "subgroupMatrixScalarMultiply") { | |
| return BuiltinFn::kSubgroupMatrixScalarMultiply; | |
| } | |
| if (name == "bufferView") { | |
| return BuiltinFn::kBufferView; | |
| } | |
| if (name == "bufferArrayView") { | |
| return BuiltinFn::kBufferArrayView; | |
| } | |
| if (name == "bufferLength") { | |
| return BuiltinFn::kBufferLength; | |
| } | |
| if (name == "print") { | |
| return BuiltinFn::kPrint; | |
| } | |
| if (name == "hasResource") { | |
| return BuiltinFn::kHasResource; | |
| } | |
| if (name == "getResource") { | |
| return BuiltinFn::kGetResource; | |
| } | |
| return BuiltinFn::kNone; | |
| } | |
| const char* str(BuiltinFn i) { | |
| switch (i) { | |
| case BuiltinFn::kNone: | |
| return "<none>"; | |
| case BuiltinFn::kAbs: | |
| return "abs"; | |
| case BuiltinFn::kAcos: | |
| return "acos"; | |
| case BuiltinFn::kAcosh: | |
| return "acosh"; | |
| case BuiltinFn::kAll: | |
| return "all"; | |
| case BuiltinFn::kAny: | |
| return "any"; | |
| case BuiltinFn::kArrayLength: | |
| return "arrayLength"; | |
| case BuiltinFn::kAsin: | |
| return "asin"; | |
| case BuiltinFn::kAsinh: | |
| return "asinh"; | |
| case BuiltinFn::kAtan: | |
| return "atan"; | |
| case BuiltinFn::kAtan2: | |
| return "atan2"; | |
| case BuiltinFn::kAtanh: | |
| return "atanh"; | |
| case BuiltinFn::kBitcast: | |
| return "bitcast"; | |
| case BuiltinFn::kCeil: | |
| return "ceil"; | |
| case BuiltinFn::kClamp: | |
| return "clamp"; | |
| case BuiltinFn::kCos: | |
| return "cos"; | |
| case BuiltinFn::kCosh: | |
| return "cosh"; | |
| case BuiltinFn::kCountLeadingZeros: | |
| return "countLeadingZeros"; | |
| case BuiltinFn::kCountOneBits: | |
| return "countOneBits"; | |
| case BuiltinFn::kCountTrailingZeros: | |
| return "countTrailingZeros"; | |
| case BuiltinFn::kCross: | |
| return "cross"; | |
| case BuiltinFn::kDegrees: | |
| return "degrees"; | |
| case BuiltinFn::kDeterminant: | |
| return "determinant"; | |
| case BuiltinFn::kDistance: | |
| return "distance"; | |
| case BuiltinFn::kDot: | |
| return "dot"; | |
| case BuiltinFn::kDot4I8Packed: | |
| return "dot4I8Packed"; | |
| case BuiltinFn::kDot4U8Packed: | |
| return "dot4U8Packed"; | |
| case BuiltinFn::kDpdx: | |
| return "dpdx"; | |
| case BuiltinFn::kDpdxCoarse: | |
| return "dpdxCoarse"; | |
| case BuiltinFn::kDpdxFine: | |
| return "dpdxFine"; | |
| case BuiltinFn::kDpdy: | |
| return "dpdy"; | |
| case BuiltinFn::kDpdyCoarse: | |
| return "dpdyCoarse"; | |
| case BuiltinFn::kDpdyFine: | |
| return "dpdyFine"; | |
| case BuiltinFn::kExp: | |
| return "exp"; | |
| case BuiltinFn::kExp2: | |
| return "exp2"; | |
| case BuiltinFn::kExtractBits: | |
| return "extractBits"; | |
| case BuiltinFn::kFaceForward: | |
| return "faceForward"; | |
| case BuiltinFn::kFirstLeadingBit: | |
| return "firstLeadingBit"; | |
| case BuiltinFn::kFirstTrailingBit: | |
| return "firstTrailingBit"; | |
| case BuiltinFn::kFloor: | |
| return "floor"; | |
| case BuiltinFn::kFma: | |
| return "fma"; | |
| case BuiltinFn::kFract: | |
| return "fract"; | |
| case BuiltinFn::kFrexp: | |
| return "frexp"; | |
| case BuiltinFn::kFwidth: | |
| return "fwidth"; | |
| case BuiltinFn::kFwidthCoarse: | |
| return "fwidthCoarse"; | |
| case BuiltinFn::kFwidthFine: | |
| return "fwidthFine"; | |
| case BuiltinFn::kInsertBits: | |
| return "insertBits"; | |
| case BuiltinFn::kInverseSqrt: | |
| return "inverseSqrt"; | |
| case BuiltinFn::kLdexp: | |
| return "ldexp"; | |
| case BuiltinFn::kLength: | |
| return "length"; | |
| case BuiltinFn::kLog: | |
| return "log"; | |
| case BuiltinFn::kLog2: | |
| return "log2"; | |
| case BuiltinFn::kMax: | |
| return "max"; | |
| case BuiltinFn::kMin: | |
| return "min"; | |
| case BuiltinFn::kMix: | |
| return "mix"; | |
| case BuiltinFn::kModf: | |
| return "modf"; | |
| case BuiltinFn::kNormalize: | |
| return "normalize"; | |
| case BuiltinFn::kPack2X16Float: | |
| return "pack2x16float"; | |
| case BuiltinFn::kPack2X16Snorm: | |
| return "pack2x16snorm"; | |
| case BuiltinFn::kPack2X16Unorm: | |
| return "pack2x16unorm"; | |
| case BuiltinFn::kPack4X8Snorm: | |
| return "pack4x8snorm"; | |
| case BuiltinFn::kPack4X8Unorm: | |
| return "pack4x8unorm"; | |
| case BuiltinFn::kPack4XI8: | |
| return "pack4xI8"; | |
| case BuiltinFn::kPack4XU8: | |
| return "pack4xU8"; | |
| case BuiltinFn::kPack4XI8Clamp: | |
| return "pack4xI8Clamp"; | |
| case BuiltinFn::kPack4XU8Clamp: | |
| return "pack4xU8Clamp"; | |
| case BuiltinFn::kPow: | |
| return "pow"; | |
| case BuiltinFn::kQuantizeToF16: | |
| return "quantizeToF16"; | |
| case BuiltinFn::kRadians: | |
| return "radians"; | |
| case BuiltinFn::kReflect: | |
| return "reflect"; | |
| case BuiltinFn::kRefract: | |
| return "refract"; | |
| case BuiltinFn::kReverseBits: | |
| return "reverseBits"; | |
| case BuiltinFn::kRound: | |
| return "round"; | |
| case BuiltinFn::kSaturate: | |
| return "saturate"; | |
| case BuiltinFn::kSelect: | |
| return "select"; | |
| case BuiltinFn::kSign: | |
| return "sign"; | |
| case BuiltinFn::kSin: | |
| return "sin"; | |
| case BuiltinFn::kSinh: | |
| return "sinh"; | |
| case BuiltinFn::kSmoothstep: | |
| return "smoothstep"; | |
| case BuiltinFn::kSqrt: | |
| return "sqrt"; | |
| case BuiltinFn::kStep: | |
| return "step"; | |
| case BuiltinFn::kTan: | |
| return "tan"; | |
| case BuiltinFn::kTanh: | |
| return "tanh"; | |
| case BuiltinFn::kTranspose: | |
| return "transpose"; | |
| case BuiltinFn::kTrunc: | |
| return "trunc"; | |
| case BuiltinFn::kUnpack2X16Float: | |
| return "unpack2x16float"; | |
| case BuiltinFn::kUnpack2X16Snorm: | |
| return "unpack2x16snorm"; | |
| case BuiltinFn::kUnpack2X16Unorm: | |
| return "unpack2x16unorm"; | |
| case BuiltinFn::kUnpack4X8Snorm: | |
| return "unpack4x8snorm"; | |
| case BuiltinFn::kUnpack4X8Unorm: | |
| return "unpack4x8unorm"; | |
| case BuiltinFn::kUnpack4XI8: | |
| return "unpack4xI8"; | |
| case BuiltinFn::kUnpack4XU8: | |
| return "unpack4xU8"; | |
| case BuiltinFn::kAddSat: | |
| return "addSat"; | |
| case BuiltinFn::kMulSat: | |
| return "mulSat"; | |
| case BuiltinFn::kStorageBarrier: | |
| return "storageBarrier"; | |
| case BuiltinFn::kWorkgroupBarrier: | |
| return "workgroupBarrier"; | |
| case BuiltinFn::kTextureBarrier: | |
| return "textureBarrier"; | |
| case BuiltinFn::kTextureDimensions: | |
| return "textureDimensions"; | |
| case BuiltinFn::kTextureGather: | |
| return "textureGather"; | |
| case BuiltinFn::kTextureGatherCompare: | |
| return "textureGatherCompare"; | |
| case BuiltinFn::kTextureNumLayers: | |
| return "textureNumLayers"; | |
| case BuiltinFn::kTextureNumLevels: | |
| return "textureNumLevels"; | |
| case BuiltinFn::kTextureNumSamples: | |
| return "textureNumSamples"; | |
| case BuiltinFn::kTextureSample: | |
| return "textureSample"; | |
| case BuiltinFn::kTextureSampleBias: | |
| return "textureSampleBias"; | |
| case BuiltinFn::kTextureSampleCompare: | |
| return "textureSampleCompare"; | |
| case BuiltinFn::kTextureSampleCompareLevel: | |
| return "textureSampleCompareLevel"; | |
| case BuiltinFn::kTextureSampleGrad: | |
| return "textureSampleGrad"; | |
| case BuiltinFn::kTextureSampleLevel: | |
| return "textureSampleLevel"; | |
| case BuiltinFn::kTextureSampleBaseClampToEdge: | |
| return "textureSampleBaseClampToEdge"; | |
| case BuiltinFn::kTextureStore: | |
| return "textureStore"; | |
| case BuiltinFn::kTextureLoad: | |
| return "textureLoad"; | |
| case BuiltinFn::kInputAttachmentLoad: | |
| return "inputAttachmentLoad"; | |
| case BuiltinFn::kAtomicLoad: | |
| return "atomicLoad"; | |
| case BuiltinFn::kAtomicStore: | |
| return "atomicStore"; | |
| case BuiltinFn::kAtomicAdd: | |
| return "atomicAdd"; | |
| case BuiltinFn::kAtomicSub: | |
| return "atomicSub"; | |
| case BuiltinFn::kAtomicMax: | |
| return "atomicMax"; | |
| case BuiltinFn::kAtomicMin: | |
| return "atomicMin"; | |
| case BuiltinFn::kAtomicAnd: | |
| return "atomicAnd"; | |
| case BuiltinFn::kAtomicOr: | |
| return "atomicOr"; | |
| case BuiltinFn::kAtomicXor: | |
| return "atomicXor"; | |
| case BuiltinFn::kAtomicExchange: | |
| return "atomicExchange"; | |
| case BuiltinFn::kAtomicCompareExchangeWeak: | |
| return "atomicCompareExchangeWeak"; | |
| case BuiltinFn::kAtomicStoreMax: | |
| return "atomicStoreMax"; | |
| case BuiltinFn::kAtomicStoreMin: | |
| return "atomicStoreMin"; | |
| case BuiltinFn::kSubgroupBallot: | |
| return "subgroupBallot"; | |
| case BuiltinFn::kSubgroupElect: | |
| return "subgroupElect"; | |
| case BuiltinFn::kSubgroupBroadcast: | |
| return "subgroupBroadcast"; | |
| case BuiltinFn::kSubgroupBroadcastFirst: | |
| return "subgroupBroadcastFirst"; | |
| case BuiltinFn::kSubgroupShuffle: | |
| return "subgroupShuffle"; | |
| case BuiltinFn::kSubgroupShuffleXor: | |
| return "subgroupShuffleXor"; | |
| case BuiltinFn::kSubgroupShuffleUp: | |
| return "subgroupShuffleUp"; | |
| case BuiltinFn::kSubgroupShuffleDown: | |
| return "subgroupShuffleDown"; | |
| case BuiltinFn::kSubgroupAdd: | |
| return "subgroupAdd"; | |
| case BuiltinFn::kSubgroupInclusiveAdd: | |
| return "subgroupInclusiveAdd"; | |
| case BuiltinFn::kSubgroupExclusiveAdd: | |
| return "subgroupExclusiveAdd"; | |
| case BuiltinFn::kSubgroupMul: | |
| return "subgroupMul"; | |
| case BuiltinFn::kSubgroupInclusiveMul: | |
| return "subgroupInclusiveMul"; | |
| case BuiltinFn::kSubgroupExclusiveMul: | |
| return "subgroupExclusiveMul"; | |
| case BuiltinFn::kSubgroupAnd: | |
| return "subgroupAnd"; | |
| case BuiltinFn::kSubgroupOr: | |
| return "subgroupOr"; | |
| case BuiltinFn::kSubgroupXor: | |
| return "subgroupXor"; | |
| case BuiltinFn::kSubgroupMin: | |
| return "subgroupMin"; | |
| case BuiltinFn::kSubgroupMax: | |
| return "subgroupMax"; | |
| case BuiltinFn::kSubgroupAll: | |
| return "subgroupAll"; | |
| case BuiltinFn::kSubgroupAny: | |
| return "subgroupAny"; | |
| case BuiltinFn::kQuadBroadcast: | |
| return "quadBroadcast"; | |
| case BuiltinFn::kQuadSwapX: | |
| return "quadSwapX"; | |
| case BuiltinFn::kQuadSwapY: | |
| return "quadSwapY"; | |
| case BuiltinFn::kQuadSwapDiagonal: | |
| return "quadSwapDiagonal"; | |
| case BuiltinFn::kSubgroupMatrixLoad: | |
| return "subgroupMatrixLoad"; | |
| case BuiltinFn::kSubgroupMatrixStore: | |
| return "subgroupMatrixStore"; | |
| case BuiltinFn::kSubgroupMatrixMultiply: | |
| return "subgroupMatrixMultiply"; | |
| case BuiltinFn::kSubgroupMatrixMultiplyAccumulate: | |
| return "subgroupMatrixMultiplyAccumulate"; | |
| case BuiltinFn::kSubgroupMatrixScalarAdd: | |
| return "subgroupMatrixScalarAdd"; | |
| case BuiltinFn::kSubgroupMatrixScalarSubtract: | |
| return "subgroupMatrixScalarSubtract"; | |
| case BuiltinFn::kSubgroupMatrixScalarMultiply: | |
| return "subgroupMatrixScalarMultiply"; | |
| case BuiltinFn::kBufferView: | |
| return "bufferView"; | |
| case BuiltinFn::kBufferArrayView: | |
| return "bufferArrayView"; | |
| case BuiltinFn::kBufferLength: | |
| return "bufferLength"; | |
| case BuiltinFn::kPrint: | |
| return "print"; | |
| case BuiltinFn::kHasResource: | |
| return "hasResource"; | |
| case BuiltinFn::kGetResource: | |
| return "getResource"; | |
| } | |
| return "<unknown>"; | |
| } | |
| bool IsTexture(BuiltinFn f) { | |
| return IsImageQuery(f) || // | |
| f == BuiltinFn::kTextureGather || // | |
| f == BuiltinFn::kTextureGatherCompare || // | |
| f == BuiltinFn::kTextureLoad || // | |
| f == BuiltinFn::kTextureSample || // | |
| f == BuiltinFn::kTextureSampleBaseClampToEdge || // | |
| f == BuiltinFn::kTextureSampleBias || // | |
| f == BuiltinFn::kTextureSampleCompare || // | |
| f == BuiltinFn::kTextureSampleCompareLevel || // | |
| f == BuiltinFn::kTextureSampleGrad || // | |
| f == BuiltinFn::kTextureSampleLevel || // | |
| f == BuiltinFn::kTextureStore || f == BuiltinFn::kInputAttachmentLoad; | |
| } | |
| bool IsImageQuery(BuiltinFn f) { | |
| return f == BuiltinFn::kTextureDimensions || | |
| f == BuiltinFn::kTextureNumLayers || f == BuiltinFn::kTextureNumLevels || | |
| f == BuiltinFn::kTextureNumSamples; | |
| } | |
| bool IsAtomic(BuiltinFn f) { | |
| return f == BuiltinFn::kAtomicLoad || f == BuiltinFn::kAtomicStore || | |
| f == BuiltinFn::kAtomicAdd || f == BuiltinFn::kAtomicSub || | |
| f == BuiltinFn::kAtomicMax || f == BuiltinFn::kAtomicMin || | |
| f == BuiltinFn::kAtomicAnd || f == BuiltinFn::kAtomicOr || | |
| f == BuiltinFn::kAtomicXor || f == BuiltinFn::kAtomicExchange || | |
| f == BuiltinFn::kAtomicCompareExchangeWeak; | |
| } | |
| bool IsSubgroup(BuiltinFn f) { | |
| switch (f) { | |
| case BuiltinFn::kSubgroupBallot: | |
| case BuiltinFn::kSubgroupElect: | |
| case BuiltinFn::kSubgroupBroadcast: | |
| case BuiltinFn::kSubgroupBroadcastFirst: | |
| case BuiltinFn::kSubgroupShuffle: | |
| case BuiltinFn::kSubgroupShuffleXor: | |
| case BuiltinFn::kSubgroupShuffleUp: | |
| case BuiltinFn::kSubgroupShuffleDown: | |
| case BuiltinFn::kSubgroupAdd: | |
| case BuiltinFn::kSubgroupInclusiveAdd: | |
| case BuiltinFn::kSubgroupExclusiveAdd: | |
| case BuiltinFn::kSubgroupMul: | |
| case BuiltinFn::kSubgroupInclusiveMul: | |
| case BuiltinFn::kSubgroupExclusiveMul: | |
| case BuiltinFn::kSubgroupAnd: | |
| case BuiltinFn::kSubgroupOr: | |
| case BuiltinFn::kSubgroupXor: | |
| case BuiltinFn::kSubgroupMin: | |
| case BuiltinFn::kSubgroupMax: | |
| case BuiltinFn::kSubgroupAll: | |
| case BuiltinFn::kSubgroupAny: | |
| case BuiltinFn::kQuadBroadcast: | |
| case BuiltinFn::kQuadSwapX: | |
| case BuiltinFn::kQuadSwapY: | |
| case BuiltinFn::kQuadSwapDiagonal: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| bool HasSideEffects(BuiltinFn f) { | |
| switch (f) { | |
| case BuiltinFn::kAtomicAdd: | |
| case BuiltinFn::kAtomicAnd: | |
| case BuiltinFn::kAtomicCompareExchangeWeak: | |
| case BuiltinFn::kAtomicExchange: | |
| case BuiltinFn::kAtomicMax: | |
| case BuiltinFn::kAtomicMin: | |
| case BuiltinFn::kAtomicOr: | |
| case BuiltinFn::kAtomicStore: | |
| case BuiltinFn::kAtomicSub: | |
| case BuiltinFn::kAtomicXor: | |
| case BuiltinFn::kTextureStore: | |
| return true; | |
| default: | |
| break; | |
| } | |
| return false; | |
| } | |
| } // namespace tint::core | |
| // clang-format on |