From 1f46d56c351da8157ccfe8560985019dfce93cc0 Mon Sep 17 00:00:00 2001 From: mmyduckx <308303735@qq.com> Date: Sun, 25 Apr 2021 15:29:12 +0800 Subject: [PATCH] Tbb spirv (#146) * add tbb ios/mac multi-arch & add SPIRV .h file in android x86_64 * remove useless folder --- .../include/glslang/SPIRV/GLSL.ext.AMD.h | 108 + .../include/glslang/SPIRV/GLSL.ext.EXT.h | 39 + .../include/glslang/SPIRV/GLSL.ext.KHR.h | 51 + .../include/glslang/SPIRV/GLSL.ext.NV.h | 81 + .../include/glslang/SPIRV/GLSL.std.450.h | 131 + .../include/glslang/SPIRV/GlslangToSpv.h | 61 + android/x86_64/include/glslang/SPIRV/Logger.h | 83 + .../glslang/SPIRV/NonSemanticDebugPrintf.h | 50 + .../include/glslang/SPIRV/SPVRemapper.h | 304 +++ .../x86_64/include/glslang/SPIRV/SpvBuilder.h | 838 +++++++ .../x86_64/include/glslang/SPIRV/SpvTools.h | 82 + .../x86_64/include/glslang/SPIRV/bitutils.h | 81 + .../include/glslang/SPIRV/disassemble.h | 53 + android/x86_64/include/glslang/SPIRV/doc.h | 258 ++ .../x86_64/include/glslang/SPIRV/hex_float.h | 1078 +++++++++ .../x86_64/include/glslang/SPIRV/spirv.hpp | 2114 +++++++++++++++++ android/x86_64/include/glslang/SPIRV/spvIR.h | 485 ++++ ios/libs/libtbb_static.a | Bin 351944 -> 732416 bytes ios/libs/libtbbmalloc_proxy_static.a | Bin 5656 -> 13032 bytes ios/libs/libtbbmalloc_static.a | Bin 116488 -> 253144 bytes mac/libs/libtbb_static.a | Bin 343016 -> 695496 bytes mac/libs/libtbbmalloc_proxy_static.a | Bin 7320 -> 13040 bytes mac/libs/libtbbmalloc_static.a | Bin 118800 -> 235408 bytes 23 files changed, 5897 insertions(+) create mode 100644 android/x86_64/include/glslang/SPIRV/GLSL.ext.AMD.h create mode 100644 android/x86_64/include/glslang/SPIRV/GLSL.ext.EXT.h create mode 100644 android/x86_64/include/glslang/SPIRV/GLSL.ext.KHR.h create mode 100644 android/x86_64/include/glslang/SPIRV/GLSL.ext.NV.h create mode 100644 android/x86_64/include/glslang/SPIRV/GLSL.std.450.h create mode 100755 android/x86_64/include/glslang/SPIRV/GlslangToSpv.h create mode 100644 android/x86_64/include/glslang/SPIRV/Logger.h create mode 100644 android/x86_64/include/glslang/SPIRV/NonSemanticDebugPrintf.h create mode 100644 android/x86_64/include/glslang/SPIRV/SPVRemapper.h create mode 100644 android/x86_64/include/glslang/SPIRV/SpvBuilder.h create mode 100644 android/x86_64/include/glslang/SPIRV/SpvTools.h create mode 100644 android/x86_64/include/glslang/SPIRV/bitutils.h create mode 100644 android/x86_64/include/glslang/SPIRV/disassemble.h create mode 100644 android/x86_64/include/glslang/SPIRV/doc.h create mode 100644 android/x86_64/include/glslang/SPIRV/hex_float.h create mode 100644 android/x86_64/include/glslang/SPIRV/spirv.hpp create mode 100755 android/x86_64/include/glslang/SPIRV/spvIR.h diff --git a/android/x86_64/include/glslang/SPIRV/GLSL.ext.AMD.h b/android/x86_64/include/glslang/SPIRV/GLSL.ext.AMD.h new file mode 100644 index 00000000..009d2f1c --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/GLSL.ext.AMD.h @@ -0,0 +1,108 @@ +/* +** 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. +*/ + +#ifndef GLSLextAMD_H +#define GLSLextAMD_H + +static const int GLSLextAMDVersion = 100; +static const int GLSLextAMDRevision = 7; + +// SPV_AMD_shader_ballot +static const char* const E_SPV_AMD_shader_ballot = "SPV_AMD_shader_ballot"; + +enum ShaderBallotAMD { + ShaderBallotBadAMD = 0, // Don't use + + SwizzleInvocationsAMD = 1, + SwizzleInvocationsMaskedAMD = 2, + WriteInvocationAMD = 3, + MbcntAMD = 4, + + ShaderBallotCountAMD +}; + +// SPV_AMD_shader_trinary_minmax +static const char* const E_SPV_AMD_shader_trinary_minmax = "SPV_AMD_shader_trinary_minmax"; + +enum ShaderTrinaryMinMaxAMD { + ShaderTrinaryMinMaxBadAMD = 0, // Don't use + + FMin3AMD = 1, + UMin3AMD = 2, + SMin3AMD = 3, + FMax3AMD = 4, + UMax3AMD = 5, + SMax3AMD = 6, + FMid3AMD = 7, + UMid3AMD = 8, + SMid3AMD = 9, + + ShaderTrinaryMinMaxCountAMD +}; + +// SPV_AMD_shader_explicit_vertex_parameter +static const char* const E_SPV_AMD_shader_explicit_vertex_parameter = "SPV_AMD_shader_explicit_vertex_parameter"; + +enum ShaderExplicitVertexParameterAMD { + ShaderExplicitVertexParameterBadAMD = 0, // Don't use + + InterpolateAtVertexAMD = 1, + + ShaderExplicitVertexParameterCountAMD +}; + +// SPV_AMD_gcn_shader +static const char* const E_SPV_AMD_gcn_shader = "SPV_AMD_gcn_shader"; + +enum GcnShaderAMD { + GcnShaderBadAMD = 0, // Don't use + + CubeFaceIndexAMD = 1, + CubeFaceCoordAMD = 2, + TimeAMD = 3, + + GcnShaderCountAMD +}; + +// SPV_AMD_gpu_shader_half_float +static const char* const E_SPV_AMD_gpu_shader_half_float = "SPV_AMD_gpu_shader_half_float"; + +// SPV_AMD_texture_gather_bias_lod +static const char* const E_SPV_AMD_texture_gather_bias_lod = "SPV_AMD_texture_gather_bias_lod"; + +// SPV_AMD_gpu_shader_int16 +static const char* const E_SPV_AMD_gpu_shader_int16 = "SPV_AMD_gpu_shader_int16"; + +// SPV_AMD_shader_image_load_store_lod +static const char* const E_SPV_AMD_shader_image_load_store_lod = "SPV_AMD_shader_image_load_store_lod"; + +// SPV_AMD_shader_fragment_mask +static const char* const E_SPV_AMD_shader_fragment_mask = "SPV_AMD_shader_fragment_mask"; + +// SPV_AMD_gpu_shader_half_float_fetch +static const char* const E_SPV_AMD_gpu_shader_half_float_fetch = "SPV_AMD_gpu_shader_half_float_fetch"; + +#endif // #ifndef GLSLextAMD_H diff --git a/android/x86_64/include/glslang/SPIRV/GLSL.ext.EXT.h b/android/x86_64/include/glslang/SPIRV/GLSL.ext.EXT.h new file mode 100644 index 00000000..40164b61 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/GLSL.ext.EXT.h @@ -0,0 +1,39 @@ +/* +** 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. +*/ + +#ifndef GLSLextEXT_H +#define GLSLextEXT_H + +static const int GLSLextEXTVersion = 100; +static const int GLSLextEXTRevision = 2; + +static const char* const E_SPV_EXT_shader_stencil_export = "SPV_EXT_shader_stencil_export"; +static const char* const E_SPV_EXT_shader_viewport_index_layer = "SPV_EXT_shader_viewport_index_layer"; +static const char* const E_SPV_EXT_fragment_fully_covered = "SPV_EXT_fragment_fully_covered"; +static const char* const E_SPV_EXT_fragment_invocation_density = "SPV_EXT_fragment_invocation_density"; +static const char* const E_SPV_EXT_demote_to_helper_invocation = "SPV_EXT_demote_to_helper_invocation"; + +#endif // #ifndef GLSLextEXT_H diff --git a/android/x86_64/include/glslang/SPIRV/GLSL.ext.KHR.h b/android/x86_64/include/glslang/SPIRV/GLSL.ext.KHR.h new file mode 100644 index 00000000..d783a8f2 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/GLSL.ext.KHR.h @@ -0,0 +1,51 @@ +/* +** Copyright (c) 2014-2020 The Khronos Group Inc. +** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +** +** 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. +*/ + +#ifndef GLSLextKHR_H +#define GLSLextKHR_H + +static const int GLSLextKHRVersion = 100; +static const int GLSLextKHRRevision = 2; + +static const char* const E_SPV_KHR_shader_ballot = "SPV_KHR_shader_ballot"; +static const char* const E_SPV_KHR_subgroup_vote = "SPV_KHR_subgroup_vote"; +static const char* const E_SPV_KHR_device_group = "SPV_KHR_device_group"; +static const char* const E_SPV_KHR_multiview = "SPV_KHR_multiview"; +static const char* const E_SPV_KHR_shader_draw_parameters = "SPV_KHR_shader_draw_parameters"; +static const char* const E_SPV_KHR_16bit_storage = "SPV_KHR_16bit_storage"; +static const char* const E_SPV_KHR_8bit_storage = "SPV_KHR_8bit_storage"; +static const char* const E_SPV_KHR_storage_buffer_storage_class = "SPV_KHR_storage_buffer_storage_class"; +static const char* const E_SPV_KHR_post_depth_coverage = "SPV_KHR_post_depth_coverage"; +static const char* const E_SPV_KHR_vulkan_memory_model = "SPV_KHR_vulkan_memory_model"; +static const char* const E_SPV_EXT_physical_storage_buffer = "SPV_EXT_physical_storage_buffer"; +static const char* const E_SPV_KHR_physical_storage_buffer = "SPV_KHR_physical_storage_buffer"; +static const char* const E_SPV_EXT_fragment_shader_interlock = "SPV_EXT_fragment_shader_interlock"; +static const char* const E_SPV_KHR_shader_clock = "SPV_KHR_shader_clock"; +static const char* const E_SPV_KHR_non_semantic_info = "SPV_KHR_non_semantic_info"; +static const char* const E_SPV_KHR_ray_tracing = "SPV_KHR_ray_tracing"; +static const char* const E_SPV_KHR_ray_query = "SPV_KHR_ray_query"; +#endif // #ifndef GLSLextKHR_H diff --git a/android/x86_64/include/glslang/SPIRV/GLSL.ext.NV.h b/android/x86_64/include/glslang/SPIRV/GLSL.ext.NV.h new file mode 100644 index 00000000..50146da1 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/GLSL.ext.NV.h @@ -0,0 +1,81 @@ +/* +** Copyright (c) 2014-2017 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. +*/ + +#ifndef GLSLextNV_H +#define GLSLextNV_H + +enum BuiltIn; +enum Decoration; +enum Op; +enum Capability; + +static const int GLSLextNVVersion = 100; +static const int GLSLextNVRevision = 11; + +//SPV_NV_sample_mask_override_coverage +const char* const E_SPV_NV_sample_mask_override_coverage = "SPV_NV_sample_mask_override_coverage"; + +//SPV_NV_geometry_shader_passthrough +const char* const E_SPV_NV_geometry_shader_passthrough = "SPV_NV_geometry_shader_passthrough"; + +//SPV_NV_viewport_array2 +const char* const E_SPV_NV_viewport_array2 = "SPV_NV_viewport_array2"; +const char* const E_ARB_shader_viewport_layer_array = "SPV_ARB_shader_viewport_layer_array"; + +//SPV_NV_stereo_view_rendering +const char* const E_SPV_NV_stereo_view_rendering = "SPV_NV_stereo_view_rendering"; + +//SPV_NVX_multiview_per_view_attributes +const char* const E_SPV_NVX_multiview_per_view_attributes = "SPV_NVX_multiview_per_view_attributes"; + +//SPV_NV_shader_subgroup_partitioned +const char* const E_SPV_NV_shader_subgroup_partitioned = "SPV_NV_shader_subgroup_partitioned"; + +//SPV_NV_fragment_shader_barycentric +const char* const E_SPV_NV_fragment_shader_barycentric = "SPV_NV_fragment_shader_barycentric"; + +//SPV_NV_compute_shader_derivatives +const char* const E_SPV_NV_compute_shader_derivatives = "SPV_NV_compute_shader_derivatives"; + +//SPV_NV_shader_image_footprint +const char* const E_SPV_NV_shader_image_footprint = "SPV_NV_shader_image_footprint"; + +//SPV_NV_mesh_shader +const char* const E_SPV_NV_mesh_shader = "SPV_NV_mesh_shader"; + +//SPV_NV_raytracing +const char* const E_SPV_NV_ray_tracing = "SPV_NV_ray_tracing"; + +//SPV_NV_shading_rate +const char* const E_SPV_NV_shading_rate = "SPV_NV_shading_rate"; + +//SPV_NV_cooperative_matrix +const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix"; + +//SPV_NV_shader_sm_builtins +const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins"; + +#endif // #ifndef GLSLextNV_H diff --git a/android/x86_64/include/glslang/SPIRV/GLSL.std.450.h b/android/x86_64/include/glslang/SPIRV/GLSL.std.450.h new file mode 100644 index 00000000..df31092b --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/GLSL.std.450.h @@ -0,0 +1,131 @@ +/* +** 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. +*/ + +#ifndef GLSLstd450_H +#define GLSLstd450_H + +static const int GLSLstd450Version = 100; +static const int GLSLstd450Revision = 1; + +enum GLSLstd450 { + GLSLstd450Bad = 0, // Don't use + + GLSLstd450Round = 1, + GLSLstd450RoundEven = 2, + GLSLstd450Trunc = 3, + GLSLstd450FAbs = 4, + GLSLstd450SAbs = 5, + GLSLstd450FSign = 6, + GLSLstd450SSign = 7, + GLSLstd450Floor = 8, + GLSLstd450Ceil = 9, + GLSLstd450Fract = 10, + + GLSLstd450Radians = 11, + GLSLstd450Degrees = 12, + GLSLstd450Sin = 13, + GLSLstd450Cos = 14, + GLSLstd450Tan = 15, + GLSLstd450Asin = 16, + GLSLstd450Acos = 17, + GLSLstd450Atan = 18, + GLSLstd450Sinh = 19, + GLSLstd450Cosh = 20, + GLSLstd450Tanh = 21, + GLSLstd450Asinh = 22, + GLSLstd450Acosh = 23, + GLSLstd450Atanh = 24, + GLSLstd450Atan2 = 25, + + GLSLstd450Pow = 26, + GLSLstd450Exp = 27, + GLSLstd450Log = 28, + GLSLstd450Exp2 = 29, + GLSLstd450Log2 = 30, + GLSLstd450Sqrt = 31, + GLSLstd450InverseSqrt = 32, + + GLSLstd450Determinant = 33, + GLSLstd450MatrixInverse = 34, + + GLSLstd450Modf = 35, // second operand needs an OpVariable to write to + GLSLstd450ModfStruct = 36, // no OpVariable operand + GLSLstd450FMin = 37, + GLSLstd450UMin = 38, + GLSLstd450SMin = 39, + GLSLstd450FMax = 40, + GLSLstd450UMax = 41, + GLSLstd450SMax = 42, + GLSLstd450FClamp = 43, + GLSLstd450UClamp = 44, + GLSLstd450SClamp = 45, + GLSLstd450FMix = 46, + GLSLstd450IMix = 47, // Reserved + GLSLstd450Step = 48, + GLSLstd450SmoothStep = 49, + + GLSLstd450Fma = 50, + GLSLstd450Frexp = 51, // second operand needs an OpVariable to write to + GLSLstd450FrexpStruct = 52, // no OpVariable operand + GLSLstd450Ldexp = 53, + + GLSLstd450PackSnorm4x8 = 54, + GLSLstd450PackUnorm4x8 = 55, + GLSLstd450PackSnorm2x16 = 56, + GLSLstd450PackUnorm2x16 = 57, + GLSLstd450PackHalf2x16 = 58, + GLSLstd450PackDouble2x32 = 59, + GLSLstd450UnpackSnorm2x16 = 60, + GLSLstd450UnpackUnorm2x16 = 61, + GLSLstd450UnpackHalf2x16 = 62, + GLSLstd450UnpackSnorm4x8 = 63, + GLSLstd450UnpackUnorm4x8 = 64, + GLSLstd450UnpackDouble2x32 = 65, + + GLSLstd450Length = 66, + GLSLstd450Distance = 67, + GLSLstd450Cross = 68, + GLSLstd450Normalize = 69, + GLSLstd450FaceForward = 70, + GLSLstd450Reflect = 71, + GLSLstd450Refract = 72, + + GLSLstd450FindILsb = 73, + GLSLstd450FindSMsb = 74, + GLSLstd450FindUMsb = 75, + + GLSLstd450InterpolateAtCentroid = 76, + GLSLstd450InterpolateAtSample = 77, + GLSLstd450InterpolateAtOffset = 78, + + GLSLstd450NMin = 79, + GLSLstd450NMax = 80, + GLSLstd450NClamp = 81, + + GLSLstd450Count +}; + +#endif // #ifndef GLSLstd450_H diff --git a/android/x86_64/include/glslang/SPIRV/GlslangToSpv.h b/android/x86_64/include/glslang/SPIRV/GlslangToSpv.h new file mode 100755 index 00000000..3907be43 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/GlslangToSpv.h @@ -0,0 +1,61 @@ +// +// Copyright (C) 2014 LunarG, Inc. +// Copyright (C) 2015-2018 Google, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. + +#pragma once + +#if defined(_MSC_VER) && _MSC_VER >= 1900 + #pragma warning(disable : 4464) // relative include path contains '..' +#endif + +#include "SpvTools.h" +#include "glslang/Include/intermediate.h" + +#include +#include + +#include "Logger.h" + +namespace glslang { + +void GetSpirvVersion(std::string&); +int GetSpirvGeneratorVersion(); +void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector& spirv, + SpvOptions* options = nullptr); +void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector& spirv, + spv::SpvBuildLogger* logger, SpvOptions* options = nullptr); +void OutputSpvBin(const std::vector& spirv, const char* baseName); +void OutputSpvHex(const std::vector& spirv, const char* baseName, const char* varName); + +} diff --git a/android/x86_64/include/glslang/SPIRV/Logger.h b/android/x86_64/include/glslang/SPIRV/Logger.h new file mode 100644 index 00000000..411367c0 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/Logger.h @@ -0,0 +1,83 @@ +// +// Copyright (C) 2016 Google, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of Google Inc. 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 HOLDERS 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. + +#ifndef GLSLANG_SPIRV_LOGGER_H +#define GLSLANG_SPIRV_LOGGER_H + +#include +#include + +namespace spv { + +// A class for holding all SPIR-V build status messages, including +// missing/TBD functionalities, warnings, and errors. +class SpvBuildLogger { +public: + SpvBuildLogger() {} + +#ifdef GLSLANG_WEB + void tbdFunctionality(const std::string& f) { } + void missingFunctionality(const std::string& f) { } + void warning(const std::string& w) { } + void error(const std::string& e) { errors.push_back(e); } + std::string getAllMessages() { return ""; } +#else + + // Registers a TBD functionality. + void tbdFunctionality(const std::string& f); + // Registers a missing functionality. + void missingFunctionality(const std::string& f); + + // Logs a warning. + void warning(const std::string& w) { warnings.push_back(w); } + // Logs an error. + void error(const std::string& e) { errors.push_back(e); } + + // Returns all messages accumulated in the order of: + // TBD functionalities, missing functionalities, warnings, errors. + std::string getAllMessages() const; +#endif + +private: + SpvBuildLogger(const SpvBuildLogger&); + + std::vector tbdFeatures; + std::vector missingFeatures; + std::vector warnings; + std::vector errors; +}; + +} // end spv namespace + +#endif // GLSLANG_SPIRV_LOGGER_H diff --git a/android/x86_64/include/glslang/SPIRV/NonSemanticDebugPrintf.h b/android/x86_64/include/glslang/SPIRV/NonSemanticDebugPrintf.h new file mode 100644 index 00000000..83796d75 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/NonSemanticDebugPrintf.h @@ -0,0 +1,50 @@ +// Copyright (c) 2020 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. +// + +#ifndef SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_ +#define SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + NonSemanticDebugPrintfRevision = 1, + NonSemanticDebugPrintfRevision_BitWidthPadding = 0x7fffffff +}; + +enum NonSemanticDebugPrintfInstructions { + NonSemanticDebugPrintfDebugPrintf = 1, + NonSemanticDebugPrintfInstructionsMax = 0x7fffffff +}; + + +#ifdef __cplusplus +} +#endif + +#endif // SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_ diff --git a/android/x86_64/include/glslang/SPIRV/SPVRemapper.h b/android/x86_64/include/glslang/SPIRV/SPVRemapper.h new file mode 100644 index 00000000..d6b9c346 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/SPVRemapper.h @@ -0,0 +1,304 @@ +// +// Copyright (C) 2015 LunarG, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. +// + +#ifndef SPIRVREMAPPER_H +#define SPIRVREMAPPER_H + +#include +#include +#include +#include + +namespace spv { + +// MSVC defines __cplusplus as an older value, even when it supports almost all of 11. +// We handle that here by making our own symbol. +#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1700) +# define use_cpp11 1 +#endif + +class spirvbin_base_t +{ +public: + enum Options { + NONE = 0, + STRIP = (1<<0), + MAP_TYPES = (1<<1), + MAP_NAMES = (1<<2), + MAP_FUNCS = (1<<3), + DCE_FUNCS = (1<<4), + DCE_VARS = (1<<5), + DCE_TYPES = (1<<6), + OPT_LOADSTORE = (1<<7), + OPT_FWD_LS = (1<<8), // EXPERIMENTAL: PRODUCES INVALID SCHEMA-0 SPIRV + MAP_ALL = (MAP_TYPES | MAP_NAMES | MAP_FUNCS), + DCE_ALL = (DCE_FUNCS | DCE_VARS | DCE_TYPES), + OPT_ALL = (OPT_LOADSTORE), + + ALL_BUT_STRIP = (MAP_ALL | DCE_ALL | OPT_ALL), + DO_EVERYTHING = (STRIP | ALL_BUT_STRIP) + }; +}; + +} // namespace SPV + +#if !defined (use_cpp11) +#include +#include + +namespace spv { +class spirvbin_t : public spirvbin_base_t +{ +public: + spirvbin_t(int /*verbose = 0*/) { } + + void remap(std::vector& /*spv*/, unsigned int /*opts = 0*/) + { + printf("Tool not compiled for C++11, which is required for SPIR-V remapping.\n"); + exit(5); + } +}; + +} // namespace SPV + +#else // defined (use_cpp11) + +#include +#include +#include +#include +#include +#include +#include + +#include "spirv.hpp" +#include "spvIR.h" + +namespace spv { + +// class to hold SPIR-V binary data for remapping, DCE, and debug stripping +class spirvbin_t : public spirvbin_base_t +{ +public: + spirvbin_t(int verbose = 0) : entryPoint(spv::NoResult), largestNewId(0), verbose(verbose), errorLatch(false) + { } + + virtual ~spirvbin_t() { } + + // remap on an existing binary in memory + void remap(std::vector& spv, std::uint32_t opts = DO_EVERYTHING); + + // Type for error/log handler functions + typedef std::function errorfn_t; + typedef std::function logfn_t; + + // Register error/log handling functions (can be lambda fn / functor / etc) + static void registerErrorHandler(errorfn_t handler) { errorHandler = handler; } + static void registerLogHandler(logfn_t handler) { logHandler = handler; } + +protected: + // This can be overridden to provide other message behavior if needed + virtual void msg(int minVerbosity, int indent, const std::string& txt) const; + +private: + // Local to global, or global to local ID map + typedef std::unordered_map idmap_t; + typedef std::unordered_set idset_t; + typedef std::unordered_map blockmap_t; + + void remap(std::uint32_t opts = DO_EVERYTHING); + + // Map of names to IDs + typedef std::unordered_map namemap_t; + + typedef std::uint32_t spirword_t; + + typedef std::pair range_t; + typedef std::function idfn_t; + typedef std::function instfn_t; + + // Special Values for ID map: + static const spv::Id unmapped; // unchanged from default value + static const spv::Id unused; // unused ID + static const int header_size; // SPIR header = 5 words + + class id_iterator_t; + + // For mapping type entries between different shaders + typedef std::vector typeentry_t; + typedef std::map globaltypes_t; + + // A set that preserves position order, and a reverse map + typedef std::set posmap_t; + typedef std::unordered_map posmap_rev_t; + + // Maps and ID to the size of its base type, if known. + typedef std::unordered_map typesize_map_t; + + // handle error + void error(const std::string& txt) const { errorLatch = true; errorHandler(txt); } + + bool isConstOp(spv::Op opCode) const; + bool isTypeOp(spv::Op opCode) const; + bool isStripOp(spv::Op opCode) const; + bool isFlowCtrl(spv::Op opCode) const; + range_t literalRange(spv::Op opCode) const; + range_t typeRange(spv::Op opCode) const; + range_t constRange(spv::Op opCode) const; + unsigned typeSizeInWords(spv::Id id) const; + unsigned idTypeSizeInWords(spv::Id id) const; + + spv::Id& asId(unsigned word) { return spv[word]; } + const spv::Id& asId(unsigned word) const { return spv[word]; } + spv::Op asOpCode(unsigned word) const { return opOpCode(spv[word]); } + std::uint32_t asOpCodeHash(unsigned word); + spv::Decoration asDecoration(unsigned word) const { return spv::Decoration(spv[word]); } + unsigned asWordCount(unsigned word) const { return opWordCount(spv[word]); } + spv::Id asTypeConstId(unsigned word) const { return asId(word + (isTypeOp(asOpCode(word)) ? 1 : 2)); } + unsigned idPos(spv::Id id) const; + + static unsigned opWordCount(spirword_t data) { return data >> spv::WordCountShift; } + static spv::Op opOpCode(spirword_t data) { return spv::Op(data & spv::OpCodeMask); } + + // Header access & set methods + spirword_t magic() const { return spv[0]; } // return magic number + spirword_t bound() const { return spv[3]; } // return Id bound from header + spirword_t bound(spirword_t b) { return spv[3] = b; } + spirword_t genmagic() const { return spv[2]; } // generator magic + spirword_t genmagic(spirword_t m) { return spv[2] = m; } + spirword_t schemaNum() const { return spv[4]; } // schema number from header + + // Mapping fns: get + spv::Id localId(spv::Id id) const { return idMapL[id]; } + + // Mapping fns: set + inline spv::Id localId(spv::Id id, spv::Id newId); + void countIds(spv::Id id); + + // Return next unused new local ID. + // NOTE: boost::dynamic_bitset would be more efficient due to find_next(), + // which std::vector doens't have. + inline spv::Id nextUnusedId(spv::Id id); + + void buildLocalMaps(); + std::string literalString(unsigned word) const; // Return literal as a std::string + int literalStringWords(const std::string& str) const { return (int(str.size())+4)/4; } + + bool isNewIdMapped(spv::Id newId) const { return isMapped(newId); } + bool isOldIdUnmapped(spv::Id oldId) const { return localId(oldId) == unmapped; } + bool isOldIdUnused(spv::Id oldId) const { return localId(oldId) == unused; } + bool isOldIdMapped(spv::Id oldId) const { return !isOldIdUnused(oldId) && !isOldIdUnmapped(oldId); } + bool isFunction(spv::Id oldId) const { return fnPos.find(oldId) != fnPos.end(); } + + // bool matchType(const globaltypes_t& globalTypes, spv::Id lt, spv::Id gt) const; + // spv::Id findType(const globaltypes_t& globalTypes, spv::Id lt) const; + std::uint32_t hashType(unsigned typeStart) const; + + spirvbin_t& process(instfn_t, idfn_t, unsigned begin = 0, unsigned end = 0); + int processInstruction(unsigned word, instfn_t, idfn_t); + + void validate() const; + void mapTypeConst(); + void mapFnBodies(); + void optLoadStore(); + void dceFuncs(); + void dceVars(); + void dceTypes(); + void mapNames(); + void foldIds(); // fold IDs to smallest space + void forwardLoadStores(); // load store forwarding (EXPERIMENTAL) + void offsetIds(); // create relative offset IDs + + void applyMap(); // remap per local name map + void mapRemainder(); // map any IDs we haven't touched yet + void stripDebug(); // strip all debug info + void stripDeadRefs(); // strips debug info for now-dead references after DCE + void strip(); // remove debug symbols + + std::vector spv; // SPIR words + + namemap_t nameMap; // ID names from OpName + + // Since we want to also do binary ops, we can't use std::vector. we could use + // boost::dynamic_bitset, but we're trying to avoid a boost dependency. + typedef std::uint64_t bits_t; + std::vector mapped; // which new IDs have been mapped + static const int mBits = sizeof(bits_t) * 4; + + bool isMapped(spv::Id id) const { return id < maxMappedId() && ((mapped[id/mBits] & (1LL<<(id%mBits))) != 0); } + void setMapped(spv::Id id) { resizeMapped(id); mapped[id/mBits] |= (1LL<<(id%mBits)); } + void resizeMapped(spv::Id id) { if (id >= maxMappedId()) mapped.resize(id/mBits+1, 0); } + size_t maxMappedId() const { return mapped.size() * mBits; } + + // Add a strip range for a given instruction starting at 'start' + // Note: avoiding brace initializers to please older versions os MSVC. + void stripInst(unsigned start) { stripRange.push_back(range_t(start, start + asWordCount(start))); } + + // Function start and end. use unordered_map because we'll have + // many fewer functions than IDs. + std::unordered_map fnPos; + + // Which functions are called, anywhere in the module, with a call count + std::unordered_map fnCalls; + + posmap_t typeConstPos; // word positions that define types & consts (ordered) + posmap_rev_t idPosR; // reverse map from IDs to positions + typesize_map_t idTypeSizeMap; // maps each ID to its type size, if known. + + std::vector idMapL; // ID {M}ap from {L}ocal to {G}lobal IDs + + spv::Id entryPoint; // module entry point + spv::Id largestNewId; // biggest new ID we have mapped anything to + + // Sections of the binary to strip, given as [begin,end) + std::vector stripRange; + + // processing options: + std::uint32_t options; + int verbose; // verbosity level + + // Error latch: this is set if the error handler is ever executed. It would be better to + // use a try/catch block and throw, but that's not desired for certain environments, so + // this is the alternative. + mutable bool errorLatch; + + static errorfn_t errorHandler; + static logfn_t logHandler; +}; + +} // namespace SPV + +#endif // defined (use_cpp11) +#endif // SPIRVREMAPPER_H diff --git a/android/x86_64/include/glslang/SPIRV/SpvBuilder.h b/android/x86_64/include/glslang/SPIRV/SpvBuilder.h new file mode 100644 index 00000000..71b90d60 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/SpvBuilder.h @@ -0,0 +1,838 @@ +// +// Copyright (C) 2014-2015 LunarG, Inc. +// Copyright (C) 2015-2020 Google, Inc. +// Copyright (C) 2017 ARM Limited. +// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. + +// +// "Builder" is an interface to fully build SPIR-V IR. Allocate one of +// these to build (a thread safe) internal SPIR-V representation (IR), +// and then dump it as a binary stream according to the SPIR-V specification. +// +// A Builder has a 1:1 relationship with a SPIR-V module. +// + +#pragma once +#ifndef SpvBuilder_H +#define SpvBuilder_H + +#include "Logger.h" +#include "spirv.hpp" +#include "spvIR.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace spv { + +typedef enum { + Spv_1_0 = (1 << 16), + Spv_1_1 = (1 << 16) | (1 << 8), + Spv_1_2 = (1 << 16) | (2 << 8), + Spv_1_3 = (1 << 16) | (3 << 8), + Spv_1_4 = (1 << 16) | (4 << 8), + Spv_1_5 = (1 << 16) | (5 << 8), +} SpvVersion; + +class Builder { +public: + Builder(unsigned int spvVersion, unsigned int userNumber, SpvBuildLogger* logger); + virtual ~Builder(); + + static const int maxMatrixSize = 4; + + unsigned int getSpvVersion() const { return spvVersion; } + + void setSource(spv::SourceLanguage lang, int version) + { + source = lang; + sourceVersion = version; + } + spv::Id getStringId(const std::string& str) + { + auto sItr = stringIds.find(str); + if (sItr != stringIds.end()) + return sItr->second; + spv::Id strId = getUniqueId(); + Instruction* fileString = new Instruction(strId, NoType, OpString); + const char* file_c_str = str.c_str(); + fileString->addStringOperand(file_c_str); + strings.push_back(std::unique_ptr(fileString)); + module.mapInstruction(fileString); + stringIds[file_c_str] = strId; + return strId; + } + void setSourceFile(const std::string& file) + { + sourceFileStringId = getStringId(file); + } + void setSourceText(const std::string& text) { sourceText = text; } + void addSourceExtension(const char* ext) { sourceExtensions.push_back(ext); } + void addModuleProcessed(const std::string& p) { moduleProcesses.push_back(p.c_str()); } + void setEmitOpLines() { emitOpLines = true; } + void addExtension(const char* ext) { extensions.insert(ext); } + void removeExtension(const char* ext) + { + extensions.erase(ext); + } + void addIncorporatedExtension(const char* ext, SpvVersion incorporatedVersion) + { + if (getSpvVersion() < static_cast(incorporatedVersion)) + addExtension(ext); + } + void promoteIncorporatedExtension(const char* baseExt, const char* promoExt, SpvVersion incorporatedVersion) + { + removeExtension(baseExt); + addIncorporatedExtension(promoExt, incorporatedVersion); + } + void addInclude(const std::string& name, const std::string& text) + { + spv::Id incId = getStringId(name); + includeFiles[incId] = &text; + } + Id import(const char*); + void setMemoryModel(spv::AddressingModel addr, spv::MemoryModel mem) + { + addressModel = addr; + memoryModel = mem; + } + + void addCapability(spv::Capability cap) { capabilities.insert(cap); } + + // To get a new for anything needing a new one. + Id getUniqueId() { return ++uniqueId; } + + // To get a set of new s, e.g., for a set of function parameters + Id getUniqueIds(int numIds) + { + Id id = uniqueId + 1; + uniqueId += numIds; + return id; + } + + // Generate OpLine for non-filename-based #line directives (ie no filename + // seen yet): Log the current line, and if different than the last one, + // issue a new OpLine using the new line and current source file name. + void setLine(int line); + + // If filename null, generate OpLine for non-filename-based line directives, + // else do filename-based: Log the current line and file, and if different + // than the last one, issue a new OpLine using the new line and file + // name. + void setLine(int line, const char* filename); + // Low-level OpLine. See setLine() for a layered helper. + void addLine(Id fileName, int line, int column); + + // For creating new types (will return old type if the requested one was already made). + Id makeVoidType(); + Id makeBoolType(); + Id makePointer(StorageClass, Id pointee); + Id makeForwardPointer(StorageClass); + Id makePointerFromForwardPointer(StorageClass, Id forwardPointerType, Id pointee); + Id makeIntegerType(int width, bool hasSign); // generic + Id makeIntType(int width) { return makeIntegerType(width, true); } + Id makeUintType(int width) { return makeIntegerType(width, false); } + Id makeFloatType(int width); + Id makeStructType(const std::vector& members, const char*); + Id makeStructResultType(Id type0, Id type1); + Id makeVectorType(Id component, int size); + Id makeMatrixType(Id component, int cols, int rows); + Id makeArrayType(Id element, Id sizeId, int stride); // 0 stride means no stride decoration + Id makeRuntimeArray(Id element); + Id makeFunctionType(Id returnType, const std::vector& paramTypes); + Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format); + Id makeSamplerType(); + Id makeSampledImageType(Id imageType); + Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols); + + // accelerationStructureNV type + Id makeAccelerationStructureType(); + // rayQueryEXT type + Id makeRayQueryType(); + + // For querying about types. + Id getTypeId(Id resultId) const { return module.getTypeId(resultId); } + Id getDerefTypeId(Id resultId) const; + Op getOpCode(Id id) const { return module.getInstruction(id)->getOpCode(); } + Op getTypeClass(Id typeId) const { return getOpCode(typeId); } + Op getMostBasicTypeClass(Id typeId) const; + int getNumComponents(Id resultId) const { return getNumTypeComponents(getTypeId(resultId)); } + int getNumTypeConstituents(Id typeId) const; + int getNumTypeComponents(Id typeId) const { return getNumTypeConstituents(typeId); } + Id getScalarTypeId(Id typeId) const; + Id getContainedTypeId(Id typeId) const; + Id getContainedTypeId(Id typeId, int) const; + StorageClass getTypeStorageClass(Id typeId) const { return module.getStorageClass(typeId); } + ImageFormat getImageTypeFormat(Id typeId) const + { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); } + + bool isPointer(Id resultId) const { return isPointerType(getTypeId(resultId)); } + bool isScalar(Id resultId) const { return isScalarType(getTypeId(resultId)); } + bool isVector(Id resultId) const { return isVectorType(getTypeId(resultId)); } + bool isMatrix(Id resultId) const { return isMatrixType(getTypeId(resultId)); } + bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); } + bool isAggregate(Id resultId) const { return isAggregateType(getTypeId(resultId)); } + bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); } + + bool isBoolType(Id typeId) + { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); } + bool isIntType(Id typeId) const + { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; } + bool isUintType(Id typeId) const + { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; } + bool isFloatType(Id typeId) const { return getTypeClass(typeId) == OpTypeFloat; } + bool isPointerType(Id typeId) const { return getTypeClass(typeId) == OpTypePointer; } + bool isScalarType(Id typeId) const + { return getTypeClass(typeId) == OpTypeFloat || getTypeClass(typeId) == OpTypeInt || + getTypeClass(typeId) == OpTypeBool; } + bool isVectorType(Id typeId) const { return getTypeClass(typeId) == OpTypeVector; } + bool isMatrixType(Id typeId) const { return getTypeClass(typeId) == OpTypeMatrix; } + bool isStructType(Id typeId) const { return getTypeClass(typeId) == OpTypeStruct; } + bool isArrayType(Id typeId) const { return getTypeClass(typeId) == OpTypeArray; } +#ifdef GLSLANG_WEB + bool isCooperativeMatrixType(Id typeId)const { return false; } +#else + bool isCooperativeMatrixType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeMatrixNV; } +#endif + bool isAggregateType(Id typeId) const + { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); } + bool isImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeImage; } + bool isSamplerType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampler; } + bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; } + bool containsType(Id typeId, Op typeOp, unsigned int width) const; + bool containsPhysicalStorageBufferOrArray(Id typeId) const; + + bool isConstantOpCode(Op opcode) const; + bool isSpecConstantOpCode(Op opcode) const; + bool isConstant(Id resultId) const { return isConstantOpCode(getOpCode(resultId)); } + bool isConstantScalar(Id resultId) const { return getOpCode(resultId) == OpConstant; } + bool isSpecConstant(Id resultId) const { return isSpecConstantOpCode(getOpCode(resultId)); } + unsigned int getConstantScalar(Id resultId) const + { return module.getInstruction(resultId)->getImmediateOperand(0); } + StorageClass getStorageClass(Id resultId) const { return getTypeStorageClass(getTypeId(resultId)); } + + int getScalarTypeWidth(Id typeId) const + { + Id scalarTypeId = getScalarTypeId(typeId); + assert(getTypeClass(scalarTypeId) == OpTypeInt || getTypeClass(scalarTypeId) == OpTypeFloat); + return module.getInstruction(scalarTypeId)->getImmediateOperand(0); + } + + int getTypeNumColumns(Id typeId) const + { + assert(isMatrixType(typeId)); + return getNumTypeConstituents(typeId); + } + int getNumColumns(Id resultId) const { return getTypeNumColumns(getTypeId(resultId)); } + int getTypeNumRows(Id typeId) const + { + assert(isMatrixType(typeId)); + return getNumTypeComponents(getContainedTypeId(typeId)); + } + int getNumRows(Id resultId) const { return getTypeNumRows(getTypeId(resultId)); } + + Dim getTypeDimensionality(Id typeId) const + { + assert(isImageType(typeId)); + return (Dim)module.getInstruction(typeId)->getImmediateOperand(1); + } + Id getImageType(Id resultId) const + { + Id typeId = getTypeId(resultId); + assert(isImageType(typeId) || isSampledImageType(typeId)); + return isSampledImageType(typeId) ? module.getInstruction(typeId)->getIdOperand(0) : typeId; + } + bool isArrayedImageType(Id typeId) const + { + assert(isImageType(typeId)); + return module.getInstruction(typeId)->getImmediateOperand(3) != 0; + } + + // For making new constants (will return old constant if the requested one was already made). + Id makeBoolConstant(bool b, bool specConstant = false); + Id makeInt8Constant(int i, bool specConstant = false) + { return makeIntConstant(makeIntType(8), (unsigned)i, specConstant); } + Id makeUint8Constant(unsigned u, bool specConstant = false) + { return makeIntConstant(makeUintType(8), u, specConstant); } + Id makeInt16Constant(int i, bool specConstant = false) + { return makeIntConstant(makeIntType(16), (unsigned)i, specConstant); } + Id makeUint16Constant(unsigned u, bool specConstant = false) + { return makeIntConstant(makeUintType(16), u, specConstant); } + Id makeIntConstant(int i, bool specConstant = false) + { return makeIntConstant(makeIntType(32), (unsigned)i, specConstant); } + Id makeUintConstant(unsigned u, bool specConstant = false) + { return makeIntConstant(makeUintType(32), u, specConstant); } + Id makeInt64Constant(long long i, bool specConstant = false) + { return makeInt64Constant(makeIntType(64), (unsigned long long)i, specConstant); } + Id makeUint64Constant(unsigned long long u, bool specConstant = false) + { return makeInt64Constant(makeUintType(64), u, specConstant); } + Id makeFloatConstant(float f, bool specConstant = false); + Id makeDoubleConstant(double d, bool specConstant = false); + Id makeFloat16Constant(float f16, bool specConstant = false); + Id makeFpConstant(Id type, double d, bool specConstant = false); + + // Turn the array of constants into a proper spv constant of the requested type. + Id makeCompositeConstant(Id type, const std::vector& comps, bool specConst = false); + + // Methods for adding information outside the CFG. + Instruction* addEntryPoint(ExecutionModel, Function*, const char* name); + void addExecutionMode(Function*, ExecutionMode mode, int value1 = -1, int value2 = -1, int value3 = -1); + void addName(Id, const char* name); + void addMemberName(Id, int member, const char* name); + void addDecoration(Id, Decoration, int num = -1); + void addDecoration(Id, Decoration, const char*); + void addDecorationId(Id id, Decoration, Id idDecoration); + void addMemberDecoration(Id, unsigned int member, Decoration, int num = -1); + void addMemberDecoration(Id, unsigned int member, Decoration, const char*); + + // At the end of what block do the next create*() instructions go? + void setBuildPoint(Block* bp) { buildPoint = bp; } + Block* getBuildPoint() const { return buildPoint; } + + // Make the entry-point function. The returned pointer is only valid + // for the lifetime of this builder. + Function* makeEntryPoint(const char*); + + // Make a shader-style function, and create its entry block if entry is non-zero. + // Return the function, pass back the entry. + // The returned pointer is only valid for the lifetime of this builder. + Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name, + const std::vector& paramTypes, const std::vector>& precisions, Block **entry = 0); + + // Create a return. An 'implicit' return is one not appearing in the source + // code. In the case of an implicit return, no post-return block is inserted. + void makeReturn(bool implicit, Id retVal = 0); + + // Generate all the code needed to finish up a function. + void leaveFunction(); + + // Create a discard. + void makeDiscard(); + + // Create a global or function local or IO variable. + Id createVariable(StorageClass, Id type, const char* name = 0, Id initializer = NoResult); + + // Create an intermediate with an undefined value. + Id createUndefined(Id type); + + // Store into an Id and return the l-value + void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, + spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0); + + // Load from an Id and return it + Id createLoad(Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, + spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0); + + // Create an OpAccessChain instruction + Id createAccessChain(StorageClass, Id base, const std::vector& offsets); + + // Create an OpArrayLength instruction + Id createArrayLength(Id base, unsigned int member); + + // Create an OpCooperativeMatrixLengthNV instruction + Id createCooperativeMatrixLength(Id type); + + // Create an OpCompositeExtract instruction + Id createCompositeExtract(Id composite, Id typeId, unsigned index); + Id createCompositeExtract(Id composite, Id typeId, const std::vector& indexes); + Id createCompositeInsert(Id object, Id composite, Id typeId, unsigned index); + Id createCompositeInsert(Id object, Id composite, Id typeId, const std::vector& indexes); + + Id createVectorExtractDynamic(Id vector, Id typeId, Id componentIndex); + Id createVectorInsertDynamic(Id vector, Id typeId, Id component, Id componentIndex); + + void createNoResultOp(Op); + void createNoResultOp(Op, Id operand); + void createNoResultOp(Op, const std::vector& operands); + void createNoResultOp(Op, const std::vector& operands); + void createControlBarrier(Scope execution, Scope memory, MemorySemanticsMask); + void createMemoryBarrier(unsigned executionScope, unsigned memorySemantics); + Id createUnaryOp(Op, Id typeId, Id operand); + Id createBinOp(Op, Id typeId, Id operand1, Id operand2); + Id createTriOp(Op, Id typeId, Id operand1, Id operand2, Id operand3); + Id createOp(Op, Id typeId, const std::vector& operands); + Id createOp(Op, Id typeId, const std::vector& operands); + Id createFunctionCall(spv::Function*, const std::vector&); + Id createSpecConstantOp(Op, Id typeId, const std::vector& operands, const std::vector& literals); + + // Take an rvalue (source) and a set of channels to extract from it to + // make a new rvalue, which is returned. + Id createRvalueSwizzle(Decoration precision, Id typeId, Id source, const std::vector& channels); + + // Take a copy of an lvalue (target) and a source of components, and set the + // source components into the lvalue where the 'channels' say to put them. + // An updated version of the target is returned. + // (No true lvalue or stores are used.) + Id createLvalueSwizzle(Id typeId, Id target, Id source, const std::vector& channels); + + // If both the id and precision are valid, the id + // gets tagged with the requested precision. + // The passed in id is always the returned id, to simplify use patterns. + Id setPrecision(Id id, Decoration precision) + { + if (precision != NoPrecision && id != NoResult) + addDecoration(id, precision); + + return id; + } + + // Can smear a scalar to a vector for the following forms: + // - promoteScalar(scalar, vector) // smear scalar to width of vector + // - promoteScalar(vector, scalar) // smear scalar to width of vector + // - promoteScalar(pointer, scalar) // smear scalar to width of what pointer points to + // - promoteScalar(scalar, scalar) // do nothing + // Other forms are not allowed. + // + // Generally, the type of 'scalar' does not need to be the same type as the components in 'vector'. + // The type of the created vector is a vector of components of the same type as the scalar. + // + // Note: One of the arguments will change, with the result coming back that way rather than + // through the return value. + void promoteScalar(Decoration precision, Id& left, Id& right); + + // Make a value by smearing the scalar to fill the type. + // vectorType should be the correct type for making a vector of scalarVal. + // (No conversions are done.) + Id smearScalar(Decoration precision, Id scalarVal, Id vectorType); + + // Create a call to a built-in function. + Id createBuiltinCall(Id resultType, Id builtins, int entryPoint, const std::vector& args); + + // List of parameters used to create a texture operation + struct TextureParameters { + Id sampler; + Id coords; + Id bias; + Id lod; + Id Dref; + Id offset; + Id offsets; + Id gradX; + Id gradY; + Id sample; + Id component; + Id texelOut; + Id lodClamp; + Id granularity; + Id coarse; + bool nonprivate; + bool volatil; + }; + + // Select the correct texture operation based on all inputs, and emit the correct instruction + Id createTextureCall(Decoration precision, Id resultType, bool sparse, bool fetch, bool proj, bool gather, + bool noImplicit, const TextureParameters&, ImageOperandsMask); + + // Emit the OpTextureQuery* instruction that was passed in. + // Figure out the right return value and type, and return it. + Id createTextureQueryCall(Op, const TextureParameters&, bool isUnsignedResult); + + Id createSamplePositionCall(Decoration precision, Id, Id); + + Id createBitFieldExtractCall(Decoration precision, Id, Id, Id, bool isSigned); + Id createBitFieldInsertCall(Decoration precision, Id, Id, Id, Id); + + // Reduction comparison for composites: For equal and not-equal resulting in a scalar. + Id createCompositeCompare(Decoration precision, Id, Id, bool /* true if for equal, false if for not-equal */); + + // OpCompositeConstruct + Id createCompositeConstruct(Id typeId, const std::vector& constituents); + + // vector or scalar constructor + Id createConstructor(Decoration precision, const std::vector& sources, Id resultTypeId); + + // matrix constructor + Id createMatrixConstructor(Decoration precision, const std::vector& sources, Id constructee); + + // Helper to use for building nested control flow with if-then-else. + class If { + public: + If(Id condition, unsigned int ctrl, Builder& builder); + ~If() {} + + void makeBeginElse(); + void makeEndIf(); + + private: + If(const If&); + If& operator=(If&); + + Builder& builder; + Id condition; + unsigned int control; + Function* function; + Block* headerBlock; + Block* thenBlock; + Block* elseBlock; + Block* mergeBlock; + }; + + // Make a switch statement. A switch has 'numSegments' of pieces of code, not containing + // any case/default labels, all separated by one or more case/default labels. Each possible + // case value v is a jump to the caseValues[v] segment. The defaultSegment is also in this + // number space. How to compute the value is given by 'condition', as in switch(condition). + // + // The SPIR-V Builder will maintain the stack of post-switch merge blocks for nested switches. + // + // Use a defaultSegment < 0 if there is no default segment (to branch to post switch). + // + // Returns the right set of basic blocks to start each code segment with, so that the caller's + // recursion stack can hold the memory for it. + // + void makeSwitch(Id condition, unsigned int control, int numSegments, const std::vector& caseValues, + const std::vector& valueToSegment, int defaultSegment, std::vector& segmentBB); + + // Add a branch to the innermost switch's merge block. + void addSwitchBreak(); + + // Move to the next code segment, passing in the return argument in makeSwitch() + void nextSwitchSegment(std::vector& segmentBB, int segment); + + // Finish off the innermost switch. + void endSwitch(std::vector& segmentBB); + + struct LoopBlocks { + LoopBlocks(Block& head, Block& body, Block& merge, Block& continue_target) : + head(head), body(body), merge(merge), continue_target(continue_target) { } + Block &head, &body, &merge, &continue_target; + private: + LoopBlocks(); + LoopBlocks& operator=(const LoopBlocks&) = delete; + }; + + // Start a new loop and prepare the builder to generate code for it. Until + // closeLoop() is called for this loop, createLoopContinue() and + // createLoopExit() will target its corresponding blocks. + LoopBlocks& makeNewLoop(); + + // Create a new block in the function containing the build point. Memory is + // owned by the function object. + Block& makeNewBlock(); + + // Add a branch to the continue_target of the current (innermost) loop. + void createLoopContinue(); + + // Add an exit (e.g. "break") from the innermost loop that we're currently + // in. + void createLoopExit(); + + // Close the innermost loop that you're in + void closeLoop(); + + // + // Access chain design for an R-Value vs. L-Value: + // + // There is a single access chain the builder is building at + // any particular time. Such a chain can be used to either to a load or + // a store, when desired. + // + // Expressions can be r-values, l-values, or both, or only r-values: + // a[b.c].d = .... // l-value + // ... = a[b.c].d; // r-value, that also looks like an l-value + // ++a[b.c].d; // r-value and l-value + // (x + y)[2]; // r-value only, can't possibly be l-value + // + // Computing an r-value means generating code. Hence, + // r-values should only be computed when they are needed, not speculatively. + // + // Computing an l-value means saving away information for later use in the compiler, + // no code is generated until the l-value is later dereferenced. It is okay + // to speculatively generate an l-value, just not okay to speculatively dereference it. + // + // The base of the access chain (the left-most variable or expression + // from which everything is based) can be set either as an l-value + // or as an r-value. Most efficient would be to set an l-value if one + // is available. If an expression was evaluated, the resulting r-value + // can be set as the chain base. + // + // The users of this single access chain can save and restore if they + // want to nest or manage multiple chains. + // + + struct AccessChain { + Id base; // for l-values, pointer to the base object, for r-values, the base object + std::vector indexChain; + Id instr; // cache the instruction that generates this access chain + std::vector swizzle; // each std::vector element selects the next GLSL component number + Id component; // a dynamic component index, can coexist with a swizzle, + // done after the swizzle, NoResult if not present + Id preSwizzleBaseType; // dereferenced type, before swizzle or component is applied; + // NoType unless a swizzle or component is present + bool isRValue; // true if 'base' is an r-value, otherwise, base is an l-value + unsigned int alignment; // bitwise OR of alignment values passed in. Accumulates worst alignment. + // Only tracks base and (optional) component selection alignment. + + // Accumulate whether anything in the chain of structures has coherent decorations. + struct CoherentFlags { + CoherentFlags() { clear(); } +#ifdef GLSLANG_WEB + void clear() { } + bool isVolatile() const { return false; } + CoherentFlags operator |=(const CoherentFlags &other) { return *this; } +#else + bool isVolatile() const { return volatil; } + bool anyCoherent() const { + return coherent || devicecoherent || queuefamilycoherent || workgroupcoherent || + subgroupcoherent || shadercallcoherent; + } + + unsigned coherent : 1; + unsigned devicecoherent : 1; + unsigned queuefamilycoherent : 1; + unsigned workgroupcoherent : 1; + unsigned subgroupcoherent : 1; + unsigned shadercallcoherent : 1; + unsigned nonprivate : 1; + unsigned volatil : 1; + unsigned isImage : 1; + + void clear() { + coherent = 0; + devicecoherent = 0; + queuefamilycoherent = 0; + workgroupcoherent = 0; + subgroupcoherent = 0; + shadercallcoherent = 0; + nonprivate = 0; + volatil = 0; + isImage = 0; + } + + CoherentFlags operator |=(const CoherentFlags &other) { + coherent |= other.coherent; + devicecoherent |= other.devicecoherent; + queuefamilycoherent |= other.queuefamilycoherent; + workgroupcoherent |= other.workgroupcoherent; + subgroupcoherent |= other.subgroupcoherent; + shadercallcoherent |= other.shadercallcoherent; + nonprivate |= other.nonprivate; + volatil |= other.volatil; + isImage |= other.isImage; + return *this; + } +#endif + }; + CoherentFlags coherentFlags; + }; + + // + // the SPIR-V builder maintains a single active chain that + // the following methods operate on + // + + // for external save and restore + AccessChain getAccessChain() { return accessChain; } + void setAccessChain(AccessChain newChain) { accessChain = newChain; } + + // clear accessChain + void clearAccessChain(); + + // set new base as an l-value base + void setAccessChainLValue(Id lValue) + { + assert(isPointer(lValue)); + accessChain.base = lValue; + } + + // set new base value as an r-value + void setAccessChainRValue(Id rValue) + { + accessChain.isRValue = true; + accessChain.base = rValue; + } + + // push offset onto the end of the chain + void accessChainPush(Id offset, AccessChain::CoherentFlags coherentFlags, unsigned int alignment) + { + accessChain.indexChain.push_back(offset); + accessChain.coherentFlags |= coherentFlags; + accessChain.alignment |= alignment; + } + + // push new swizzle onto the end of any existing swizzle, merging into a single swizzle + void accessChainPushSwizzle(std::vector& swizzle, Id preSwizzleBaseType, + AccessChain::CoherentFlags coherentFlags, unsigned int alignment); + + // push a dynamic component selection onto the access chain, only applicable with a + // non-trivial swizzle or no swizzle + void accessChainPushComponent(Id component, Id preSwizzleBaseType, AccessChain::CoherentFlags coherentFlags, + unsigned int alignment) + { + if (accessChain.swizzle.size() != 1) { + accessChain.component = component; + if (accessChain.preSwizzleBaseType == NoType) + accessChain.preSwizzleBaseType = preSwizzleBaseType; + } + accessChain.coherentFlags |= coherentFlags; + accessChain.alignment |= alignment; + } + + // use accessChain and swizzle to store value + void accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, + spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0); + + // use accessChain and swizzle to load an r-value + Id accessChainLoad(Decoration precision, Decoration nonUniform, Id ResultType, + spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax, + unsigned int alignment = 0); + + // Return whether or not the access chain can be represented in SPIR-V + // as an l-value. + // E.g., a[3].yx cannot be, while a[3].y and a[3].y[x] can be. + bool isSpvLvalue() const { return accessChain.swizzle.size() <= 1; } + + // get the direct pointer for an l-value + Id accessChainGetLValue(); + + // Get the inferred SPIR-V type of the result of the current access chain, + // based on the type of the base and the chain of dereferences. + Id accessChainGetInferredType(); + + // Add capabilities, extensions, remove unneeded decorations, etc., + // based on the resulting SPIR-V. + void postProcess(); + + // Prune unreachable blocks in the CFG and remove unneeded decorations. + void postProcessCFG(); + +#ifndef GLSLANG_WEB + // Add capabilities, extensions based on instructions in the module. + void postProcessFeatures(); + // Hook to visit each instruction in a block in a function + void postProcess(Instruction&); + // Hook to visit each non-32-bit sized float/int operation in a block. + void postProcessType(const Instruction&, spv::Id typeId); +#endif + + void dump(std::vector&) const; + + void createBranch(Block* block); + void createConditionalBranch(Id condition, Block* thenBlock, Block* elseBlock); + void createLoopMerge(Block* mergeBlock, Block* continueBlock, unsigned int control, + const std::vector& operands); + + // Sets to generate opcode for specialization constants. + void setToSpecConstCodeGenMode() { generatingOpCodeForSpecConst = true; } + // Sets to generate opcode for non-specialization constants (normal mode). + void setToNormalCodeGenMode() { generatingOpCodeForSpecConst = false; } + // Check if the builder is generating code for spec constants. + bool isInSpecConstCodeGenMode() { return generatingOpCodeForSpecConst; } + + protected: + Id makeIntConstant(Id typeId, unsigned value, bool specConstant); + Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant); + Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value); + Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2); + Id findCompositeConstant(Op typeClass, Id typeId, const std::vector& comps); + Id findStructConstant(Id typeId, const std::vector& comps); + Id collapseAccessChain(); + void remapDynamicSwizzle(); + void transferAccessChainSwizzle(bool dynamic); + void simplifyAccessChainSwizzle(); + void createAndSetNoPredecessorBlock(const char*); + void createSelectionMerge(Block* mergeBlock, unsigned int control); + void dumpSourceInstructions(std::vector&) const; + void dumpSourceInstructions(const spv::Id fileId, const std::string& text, std::vector&) const; + void dumpInstructions(std::vector&, const std::vector >&) const; + void dumpModuleProcesses(std::vector&) const; + spv::MemoryAccessMask sanitizeMemoryAccessForStorageClass(spv::MemoryAccessMask memoryAccess, StorageClass sc) + const; + + unsigned int spvVersion; // the version of SPIR-V to emit in the header + SourceLanguage source; + int sourceVersion; + spv::Id sourceFileStringId; + std::string sourceText; + int currentLine; + const char* currentFile; + bool emitOpLines; + std::set extensions; + std::vector sourceExtensions; + std::vector moduleProcesses; + AddressingModel addressModel; + MemoryModel memoryModel; + std::set capabilities; + int builderNumber; + Module module; + Block* buildPoint; + Id uniqueId; + Function* entryPointFunction; + bool generatingOpCodeForSpecConst; + AccessChain accessChain; + + // special blocks of instructions for output + std::vector > strings; + std::vector > imports; + std::vector > entryPoints; + std::vector > executionModes; + std::vector > names; + std::vector > decorations; + std::vector > constantsTypesGlobals; + std::vector > externals; + std::vector > functions; + + // not output, internally used for quick & dirty canonical (unique) creation + + // map type opcodes to constant inst. + std::unordered_map> groupedConstants; + // map struct-id to constant instructions + std::unordered_map> groupedStructConstants; + // map type opcodes to type instructions + std::unordered_map> groupedTypes; + + // stack of switches + std::stack switchMerges; + + // Our loop stack. + std::stack loops; + + // map from strings to their string ids + std::unordered_map stringIds; + + // map from include file name ids to their contents + std::map includeFiles; + + // The stream for outputting warnings and errors. + SpvBuildLogger* logger; +}; // end Builder class + +}; // end spv namespace + +#endif // SpvBuilder_H diff --git a/android/x86_64/include/glslang/SPIRV/SpvTools.h b/android/x86_64/include/glslang/SPIRV/SpvTools.h new file mode 100644 index 00000000..59c914da --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/SpvTools.h @@ -0,0 +1,82 @@ +// +// Copyright (C) 2014-2016 LunarG, Inc. +// Copyright (C) 2018 Google, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. + +// +// Call into SPIRV-Tools to disassemble, validate, and optimize. +// + +#pragma once +#ifndef GLSLANG_SPV_TOOLS_H +#define GLSLANG_SPV_TOOLS_H + +#ifdef ENABLE_OPT +#include +#include +#endif + +#include "glslang/MachineIndependent/localintermediate.h" +#include "Logger.h" + +namespace glslang { + +struct SpvOptions { + SpvOptions() : generateDebugInfo(false), disableOptimizer(true), + optimizeSize(false), disassemble(false), validate(false) { } + bool generateDebugInfo; + bool disableOptimizer; + bool optimizeSize; + bool disassemble; + bool validate; +}; + +#ifdef ENABLE_OPT + +// Use the SPIRV-Tools disassembler to print SPIR-V. +void SpirvToolsDisassemble(std::ostream& out, const std::vector& spirv); + +// Apply the SPIRV-Tools validator to generated SPIR-V. +void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector& spirv, + spv::SpvBuildLogger*, bool prelegalization); + +// Apply the SPIRV-Tools optimizer to generated SPIR-V, for the purpose of +// legalizing HLSL SPIR-V. +void SpirvToolsLegalize(const glslang::TIntermediate& intermediate, std::vector& spirv, + spv::SpvBuildLogger*, const SpvOptions*); + +#endif + +} // end namespace glslang + +#endif // GLSLANG_SPV_TOOLS_H diff --git a/android/x86_64/include/glslang/SPIRV/bitutils.h b/android/x86_64/include/glslang/SPIRV/bitutils.h new file mode 100644 index 00000000..22e44cec --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/bitutils.h @@ -0,0 +1,81 @@ +// Copyright (c) 2015-2016 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef LIBSPIRV_UTIL_BITUTILS_H_ +#define LIBSPIRV_UTIL_BITUTILS_H_ + +#include +#include + +namespace spvutils { + +// Performs a bitwise copy of source to the destination type Dest. +template +Dest BitwiseCast(Src source) { + Dest dest; + static_assert(sizeof(source) == sizeof(dest), + "BitwiseCast: Source and destination must have the same size"); + std::memcpy(static_cast(&dest), &source, sizeof(dest)); + return dest; +} + +// SetBits returns an integer of type with bits set +// for position through , counting from the least +// significant bit. In particular when Num == 0, no positions are set to 1. +// A static assert will be triggered if First + Num > sizeof(T) * 8, that is, +// a bit that will not fit in the underlying type is set. +template +struct SetBits { + static_assert(First < sizeof(T) * 8, + "Tried to set a bit that is shifted too far."); + const static T get = (T(1) << First) | SetBits::get; +}; + +template +struct SetBits { + const static T get = T(0); +}; + +// This is all compile-time so we can put our tests right here. +static_assert(SetBits::get == uint32_t(0x00000000), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x00000001), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x80000000), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x00000006), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0xc0000000), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0x7FFFFFFF), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0xFFFFFFFF), + "SetBits failed"); +static_assert(SetBits::get == uint32_t(0xFFFF0000), + "SetBits failed"); + +static_assert(SetBits::get == uint64_t(0x0000000000000001LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0x8000000000000000LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0xc000000000000000LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0x0000000080000000LL), + "SetBits failed"); +static_assert(SetBits::get == uint64_t(0x00000000FFFF0000LL), + "SetBits failed"); + +} // namespace spvutils + +#endif // LIBSPIRV_UTIL_BITUTILS_H_ diff --git a/android/x86_64/include/glslang/SPIRV/disassemble.h b/android/x86_64/include/glslang/SPIRV/disassemble.h new file mode 100644 index 00000000..b6a46357 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/disassemble.h @@ -0,0 +1,53 @@ +// +// Copyright (C) 2014-2015 LunarG, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. + +// +// Disassembler for SPIR-V. +// + +#pragma once +#ifndef disassembler_H +#define disassembler_H + +#include +#include + +namespace spv { + + // disassemble with glslang custom disassembler + void Disassemble(std::ostream& out, const std::vector&); + +} // end namespace spv + +#endif // disassembler_H diff --git a/android/x86_64/include/glslang/SPIRV/doc.h b/android/x86_64/include/glslang/SPIRV/doc.h new file mode 100644 index 00000000..293256a2 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/doc.h @@ -0,0 +1,258 @@ +// +// Copyright (C) 2014-2015 LunarG, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. + +// +// Parameterize the SPIR-V enumerants. +// + +#pragma once + +#include "spirv.hpp" + +#include + +namespace spv { + +// Fill in all the parameters +void Parameterize(); + +// Return the English names of all the enums. +const char* SourceString(int); +const char* AddressingString(int); +const char* MemoryString(int); +const char* ExecutionModelString(int); +const char* ExecutionModeString(int); +const char* StorageClassString(int); +const char* DecorationString(int); +const char* BuiltInString(int); +const char* DimensionString(int); +const char* SelectControlString(int); +const char* LoopControlString(int); +const char* FunctionControlString(int); +const char* SamplerAddressingModeString(int); +const char* SamplerFilterModeString(int); +const char* ImageFormatString(int); +const char* ImageChannelOrderString(int); +const char* ImageChannelTypeString(int); +const char* ImageChannelDataTypeString(int type); +const char* ImageOperandsString(int format); +const char* ImageOperands(int); +const char* FPFastMathString(int); +const char* FPRoundingModeString(int); +const char* LinkageTypeString(int); +const char* FuncParamAttrString(int); +const char* AccessQualifierString(int); +const char* MemorySemanticsString(int); +const char* MemoryAccessString(int); +const char* ExecutionScopeString(int); +const char* GroupOperationString(int); +const char* KernelEnqueueFlagsString(int); +const char* KernelProfilingInfoString(int); +const char* CapabilityString(int); +const char* OpcodeString(int); +const char* ScopeString(int mem); + +// For grouping opcodes into subsections +enum OpcodeClass { + OpClassMisc, + OpClassDebug, + OpClassAnnotate, + OpClassExtension, + OpClassMode, + OpClassType, + OpClassConstant, + OpClassMemory, + OpClassFunction, + OpClassImage, + OpClassConvert, + OpClassComposite, + OpClassArithmetic, + OpClassBit, + OpClassRelationalLogical, + OpClassDerivative, + OpClassFlowControl, + OpClassAtomic, + OpClassPrimitive, + OpClassBarrier, + OpClassGroup, + OpClassDeviceSideEnqueue, + OpClassPipe, + + OpClassCount, + OpClassMissing // all instructions start out as missing +}; + +// For parameterizing operands. +enum OperandClass { + OperandNone, + OperandId, + OperandVariableIds, + OperandOptionalLiteral, + OperandOptionalLiteralString, + OperandVariableLiterals, + OperandVariableIdLiteral, + OperandVariableLiteralId, + OperandLiteralNumber, + OperandLiteralString, + OperandSource, + OperandExecutionModel, + OperandAddressing, + OperandMemory, + OperandExecutionMode, + OperandStorage, + OperandDimensionality, + OperandSamplerAddressingMode, + OperandSamplerFilterMode, + OperandSamplerImageFormat, + OperandImageChannelOrder, + OperandImageChannelDataType, + OperandImageOperands, + OperandFPFastMath, + OperandFPRoundingMode, + OperandLinkageType, + OperandAccessQualifier, + OperandFuncParamAttr, + OperandDecoration, + OperandBuiltIn, + OperandSelect, + OperandLoop, + OperandFunction, + OperandMemorySemantics, + OperandMemoryAccess, + OperandScope, + OperandGroupOperation, + OperandKernelEnqueueFlags, + OperandKernelProfilingInfo, + OperandCapability, + + OperandOpcode, + + OperandCount +}; + +// Any specific enum can have a set of capabilities that allow it: +typedef std::vector EnumCaps; + +// Parameterize a set of operands with their OperandClass(es) and descriptions. +class OperandParameters { +public: + OperandParameters() { } + void push(OperandClass oc, const char* d, bool opt = false) + { + opClass.push_back(oc); + desc.push_back(d); + optional.push_back(opt); + } + void setOptional(); + OperandClass getClass(int op) const { return opClass[op]; } + const char* getDesc(int op) const { return desc[op]; } + bool isOptional(int op) const { return optional[op]; } + int getNum() const { return (int)opClass.size(); } + +protected: + std::vector opClass; + std::vector desc; + std::vector optional; +}; + +// Parameterize an enumerant +class EnumParameters { +public: + EnumParameters() : desc(0) { } + const char* desc; +}; + +// Parameterize a set of enumerants that form an enum +class EnumDefinition : public EnumParameters { +public: + EnumDefinition() : + ceiling(0), bitmask(false), getName(0), enumParams(0), operandParams(0) { } + void set(int ceil, const char* (*name)(int), EnumParameters* ep, bool mask = false) + { + ceiling = ceil; + getName = name; + bitmask = mask; + enumParams = ep; + } + void setOperands(OperandParameters* op) { operandParams = op; } + int ceiling; // ceiling of enumerants + bool bitmask; // true if these enumerants combine into a bitmask + const char* (*getName)(int); // a function that returns the name for each enumerant value (or shift) + EnumParameters* enumParams; // parameters for each individual enumerant + OperandParameters* operandParams; // sets of operands +}; + +// Parameterize an instruction's logical format, including its known set of operands, +// per OperandParameters above. +class InstructionParameters { +public: + InstructionParameters() : + opDesc("TBD"), + opClass(OpClassMissing), + typePresent(true), // most normal, only exceptions have to be spelled out + resultPresent(true) // most normal, only exceptions have to be spelled out + { } + + void setResultAndType(bool r, bool t) + { + resultPresent = r; + typePresent = t; + } + + bool hasResult() const { return resultPresent != 0; } + bool hasType() const { return typePresent != 0; } + + const char* opDesc; + OpcodeClass opClass; + OperandParameters operands; + +protected: + int typePresent : 1; + int resultPresent : 1; +}; + +// The set of objects that hold all the instruction/operand +// parameterization information. +extern InstructionParameters InstructionDesc[]; + +// These hold definitions of the enumerants used for operands +extern EnumDefinition OperandClassParams[]; + +const char* GetOperandDesc(OperandClass operand); +void PrintImmediateRow(int imm, const char* name, const EnumParameters* enumParams, bool caps, bool hex = false); +const char* AccessQualifierString(int attr); + +void PrintOperands(const OperandParameters& operands, int reservedOperands); + +} // end namespace spv diff --git a/android/x86_64/include/glslang/SPIRV/hex_float.h b/android/x86_64/include/glslang/SPIRV/hex_float.h new file mode 100644 index 00000000..8be8e9f7 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/hex_float.h @@ -0,0 +1,1078 @@ +// Copyright (c) 2015-2016 The Khronos Group Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef LIBSPIRV_UTIL_HEX_FLOAT_H_ +#define LIBSPIRV_UTIL_HEX_FLOAT_H_ + +#include +#include +#include +#include +#include +#include +#include + +#if defined(_MSC_VER) && _MSC_VER < 1800 +namespace std { +bool isnan(double f) +{ + return ::_isnan(f) != 0; +} +bool isinf(double f) +{ + return ::_finite(f) == 0; +} +} +#endif + +#include "bitutils.h" + +namespace spvutils { + +class Float16 { + public: + Float16(uint16_t v) : val(v) {} + Float16() {} + static bool isNan(const Float16& val) { + return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) != 0); + } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(const Float16& val) { + return ((val.val & 0x7C00) == 0x7C00) && ((val.val & 0x3FF) == 0); + } + Float16(const Float16& other) { val = other.val; } + uint16_t get_value() const { return val; } + + // Returns the maximum normal value. + static Float16 max() { return Float16(0x7bff); } + // Returns the lowest normal value. + static Float16 lowest() { return Float16(0xfbff); } + + private: + uint16_t val; +}; + +// To specialize this type, you must override uint_type to define +// an unsigned integer that can fit your floating point type. +// You must also add a isNan function that returns true if +// a value is Nan. +template +struct FloatProxyTraits { + typedef void uint_type; +}; + +template <> +struct FloatProxyTraits { + typedef uint32_t uint_type; + static bool isNan(float f) { return std::isnan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(float f) { return std::isinf(f); } + // Returns the maximum normal value. + static float max() { return std::numeric_limits::max(); } + // Returns the lowest normal value. + static float lowest() { return std::numeric_limits::lowest(); } +}; + +template <> +struct FloatProxyTraits { + typedef uint64_t uint_type; + static bool isNan(double f) { return std::isnan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(double f) { return std::isinf(f); } + // Returns the maximum normal value. + static double max() { return std::numeric_limits::max(); } + // Returns the lowest normal value. + static double lowest() { return std::numeric_limits::lowest(); } +}; + +template <> +struct FloatProxyTraits { + typedef uint16_t uint_type; + static bool isNan(Float16 f) { return Float16::isNan(f); } + // Returns true if the given value is any kind of infinity. + static bool isInfinity(Float16 f) { return Float16::isInfinity(f); } + // Returns the maximum normal value. + static Float16 max() { return Float16::max(); } + // Returns the lowest normal value. + static Float16 lowest() { return Float16::lowest(); } +}; + +// Since copying a floating point number (especially if it is NaN) +// does not guarantee that bits are preserved, this class lets us +// store the type and use it as a float when necessary. +template +class FloatProxy { + public: + typedef typename FloatProxyTraits::uint_type uint_type; + + // Since this is to act similar to the normal floats, + // do not initialize the data by default. + FloatProxy() {} + + // Intentionally non-explicit. This is a proxy type so + // implicit conversions allow us to use it more transparently. + FloatProxy(T val) { data_ = BitwiseCast(val); } + + // Intentionally non-explicit. This is a proxy type so + // implicit conversions allow us to use it more transparently. + FloatProxy(uint_type val) { data_ = val; } + + // This is helpful to have and is guaranteed not to stomp bits. + FloatProxy operator-() const { + return static_cast(data_ ^ + (uint_type(0x1) << (sizeof(T) * 8 - 1))); + } + + // Returns the data as a floating point value. + T getAsFloat() const { return BitwiseCast(data_); } + + // Returns the raw data. + uint_type data() const { return data_; } + + // Returns true if the value represents any type of NaN. + bool isNan() { return FloatProxyTraits::isNan(getAsFloat()); } + // Returns true if the value represents any type of infinity. + bool isInfinity() { return FloatProxyTraits::isInfinity(getAsFloat()); } + + // Returns the maximum normal value. + static FloatProxy max() { + return FloatProxy(FloatProxyTraits::max()); + } + // Returns the lowest normal value. + static FloatProxy lowest() { + return FloatProxy(FloatProxyTraits::lowest()); + } + + private: + uint_type data_; +}; + +template +bool operator==(const FloatProxy& first, const FloatProxy& second) { + return first.data() == second.data(); +} + +// Reads a FloatProxy value as a normal float from a stream. +template +std::istream& operator>>(std::istream& is, FloatProxy& value) { + T float_val; + is >> float_val; + value = FloatProxy(float_val); + return is; +} + +// This is an example traits. It is not meant to be used in practice, but will +// be the default for any non-specialized type. +template +struct HexFloatTraits { + // Integer type that can store this hex-float. + typedef void uint_type; + // Signed integer type that can store this hex-float. + typedef void int_type; + // The numerical type that this HexFloat represents. + typedef void underlying_type; + // The type needed to construct the underlying type. + typedef void native_type; + // The number of bits that are actually relevant in the uint_type. + // This allows us to deal with, for example, 24-bit values in a 32-bit + // integer. + static const uint32_t num_used_bits = 0; + // Number of bits that represent the exponent. + static const uint32_t num_exponent_bits = 0; + // Number of bits that represent the fractional part. + static const uint32_t num_fraction_bits = 0; + // The bias of the exponent. (How much we need to subtract from the stored + // value to get the correct value.) + static const uint32_t exponent_bias = 0; +}; + +// Traits for IEEE float. +// 1 sign bit, 8 exponent bits, 23 fractional bits. +template <> +struct HexFloatTraits> { + typedef uint32_t uint_type; + typedef int32_t int_type; + typedef FloatProxy underlying_type; + typedef float native_type; + static const uint_type num_used_bits = 32; + static const uint_type num_exponent_bits = 8; + static const uint_type num_fraction_bits = 23; + static const uint_type exponent_bias = 127; +}; + +// Traits for IEEE double. +// 1 sign bit, 11 exponent bits, 52 fractional bits. +template <> +struct HexFloatTraits> { + typedef uint64_t uint_type; + typedef int64_t int_type; + typedef FloatProxy underlying_type; + typedef double native_type; + static const uint_type num_used_bits = 64; + static const uint_type num_exponent_bits = 11; + static const uint_type num_fraction_bits = 52; + static const uint_type exponent_bias = 1023; +}; + +// Traits for IEEE half. +// 1 sign bit, 5 exponent bits, 10 fractional bits. +template <> +struct HexFloatTraits> { + typedef uint16_t uint_type; + typedef int16_t int_type; + typedef uint16_t underlying_type; + typedef uint16_t native_type; + static const uint_type num_used_bits = 16; + static const uint_type num_exponent_bits = 5; + static const uint_type num_fraction_bits = 10; + static const uint_type exponent_bias = 15; +}; + +enum round_direction { + kRoundToZero, + kRoundToNearestEven, + kRoundToPositiveInfinity, + kRoundToNegativeInfinity +}; + +// Template class that houses a floating pointer number. +// It exposes a number of constants based on the provided traits to +// assist in interpreting the bits of the value. +template > +class HexFloat { + public: + typedef typename Traits::uint_type uint_type; + typedef typename Traits::int_type int_type; + typedef typename Traits::underlying_type underlying_type; + typedef typename Traits::native_type native_type; + + explicit HexFloat(T f) : value_(f) {} + + T value() const { return value_; } + void set_value(T f) { value_ = f; } + + // These are all written like this because it is convenient to have + // compile-time constants for all of these values. + + // Pass-through values to save typing. + static const uint32_t num_used_bits = Traits::num_used_bits; + static const uint32_t exponent_bias = Traits::exponent_bias; + static const uint32_t num_exponent_bits = Traits::num_exponent_bits; + static const uint32_t num_fraction_bits = Traits::num_fraction_bits; + + // Number of bits to shift left to set the highest relevant bit. + static const uint32_t top_bit_left_shift = num_used_bits - 1; + // How many nibbles (hex characters) the fractional part takes up. + static const uint32_t fraction_nibbles = (num_fraction_bits + 3) / 4; + // If the fractional part does not fit evenly into a hex character (4-bits) + // then we have to left-shift to get rid of leading 0s. This is the amount + // we have to shift (might be 0). + static const uint32_t num_overflow_bits = + fraction_nibbles * 4 - num_fraction_bits; + + // The representation of the fraction, not the actual bits. This + // includes the leading bit that is usually implicit. + static const uint_type fraction_represent_mask = + spvutils::SetBits::get; + + // The topmost bit in the nibble-aligned fraction. + static const uint_type fraction_top_bit = + uint_type(1) << (num_fraction_bits + num_overflow_bits - 1); + + // The least significant bit in the exponent, which is also the bit + // immediately to the left of the significand. + static const uint_type first_exponent_bit = uint_type(1) + << (num_fraction_bits); + + // The mask for the encoded fraction. It does not include the + // implicit bit. + static const uint_type fraction_encode_mask = + spvutils::SetBits::get; + + // The bit that is used as a sign. + static const uint_type sign_mask = uint_type(1) << top_bit_left_shift; + + // The bits that represent the exponent. + static const uint_type exponent_mask = + spvutils::SetBits::get; + + // How far left the exponent is shifted. + static const uint32_t exponent_left_shift = num_fraction_bits; + + // How far from the right edge the fraction is shifted. + static const uint32_t fraction_right_shift = + static_cast(sizeof(uint_type) * 8) - num_fraction_bits; + + // The maximum representable unbiased exponent. + static const int_type max_exponent = + (exponent_mask >> num_fraction_bits) - exponent_bias; + // The minimum representable exponent for normalized numbers. + static const int_type min_exponent = -static_cast(exponent_bias); + + // Returns the bits associated with the value. + uint_type getBits() const { return spvutils::BitwiseCast(value_); } + + // Returns the bits associated with the value, without the leading sign bit. + uint_type getUnsignedBits() const { + return static_cast(spvutils::BitwiseCast(value_) & + ~sign_mask); + } + + // Returns the bits associated with the exponent, shifted to start at the + // lsb of the type. + const uint_type getExponentBits() const { + return static_cast((getBits() & exponent_mask) >> + num_fraction_bits); + } + + // Returns the exponent in unbiased form. This is the exponent in the + // human-friendly form. + const int_type getUnbiasedExponent() const { + return static_cast(getExponentBits() - exponent_bias); + } + + // Returns just the significand bits from the value. + const uint_type getSignificandBits() const { + return getBits() & fraction_encode_mask; + } + + // If the number was normalized, returns the unbiased exponent. + // If the number was denormal, normalize the exponent first. + const int_type getUnbiasedNormalizedExponent() const { + if ((getBits() & ~sign_mask) == 0) { // special case if everything is 0 + return 0; + } + int_type exp = getUnbiasedExponent(); + if (exp == min_exponent) { // We are in denorm land. + uint_type significand_bits = getSignificandBits(); + while ((significand_bits & (first_exponent_bit >> 1)) == 0) { + significand_bits = static_cast(significand_bits << 1); + exp = static_cast(exp - 1); + } + significand_bits &= fraction_encode_mask; + } + return exp; + } + + // Returns the signficand after it has been normalized. + const uint_type getNormalizedSignificand() const { + int_type unbiased_exponent = getUnbiasedNormalizedExponent(); + uint_type significand = getSignificandBits(); + for (int_type i = unbiased_exponent; i <= min_exponent; ++i) { + significand = static_cast(significand << 1); + } + significand &= fraction_encode_mask; + return significand; + } + + // Returns true if this number represents a negative value. + bool isNegative() const { return (getBits() & sign_mask) != 0; } + + // Sets this HexFloat from the individual components. + // Note this assumes EVERY significand is normalized, and has an implicit + // leading one. This means that the only way that this method will set 0, + // is if you set a number so denormalized that it underflows. + // Do not use this method with raw bits extracted from a subnormal number, + // since subnormals do not have an implicit leading 1 in the significand. + // The significand is also expected to be in the + // lowest-most num_fraction_bits of the uint_type. + // The exponent is expected to be unbiased, meaning an exponent of + // 0 actually means 0. + // If underflow_round_up is set, then on underflow, if a number is non-0 + // and would underflow, we round up to the smallest denorm. + void setFromSignUnbiasedExponentAndNormalizedSignificand( + bool negative, int_type exponent, uint_type significand, + bool round_denorm_up) { + bool significand_is_zero = significand == 0; + + if (exponent <= min_exponent) { + // If this was denormalized, then we have to shift the bit on, meaning + // the significand is not zero. + significand_is_zero = false; + significand |= first_exponent_bit; + significand = static_cast(significand >> 1); + } + + while (exponent < min_exponent) { + significand = static_cast(significand >> 1); + ++exponent; + } + + if (exponent == min_exponent) { + if (significand == 0 && !significand_is_zero && round_denorm_up) { + significand = static_cast(0x1); + } + } + + uint_type new_value = 0; + if (negative) { + new_value = static_cast(new_value | sign_mask); + } + exponent = static_cast(exponent + exponent_bias); + assert(exponent >= 0); + + // put it all together + exponent = static_cast((exponent << exponent_left_shift) & + exponent_mask); + significand = static_cast(significand & fraction_encode_mask); + new_value = static_cast(new_value | (exponent | significand)); + value_ = BitwiseCast(new_value); + } + + // Increments the significand of this number by the given amount. + // If this would spill the significand into the implicit bit, + // carry is set to true and the significand is shifted to fit into + // the correct location, otherwise carry is set to false. + // All significands and to_increment are assumed to be within the bounds + // for a valid significand. + static uint_type incrementSignificand(uint_type significand, + uint_type to_increment, bool* carry) { + significand = static_cast(significand + to_increment); + *carry = false; + if (significand & first_exponent_bit) { + *carry = true; + // The implicit 1-bit will have carried, so we should zero-out the + // top bit and shift back. + significand = static_cast(significand & ~first_exponent_bit); + significand = static_cast(significand >> 1); + } + return significand; + } + + // These exist because MSVC throws warnings on negative right-shifts + // even if they are not going to be executed. Eg: + // constant_number < 0? 0: constant_number + // These convert the negative left-shifts into right shifts. + + template + uint_type negatable_left_shift(int_type N, uint_type val) + { + if(N >= 0) + return val << N; + + return val >> -N; + } + + template + uint_type negatable_right_shift(int_type N, uint_type val) + { + if(N >= 0) + return val >> N; + + return val << -N; + } + + // Returns the significand, rounded to fit in a significand in + // other_T. This is shifted so that the most significant + // bit of the rounded number lines up with the most significant bit + // of the returned significand. + template + typename other_T::uint_type getRoundedNormalizedSignificand( + round_direction dir, bool* carry_bit) { + typedef typename other_T::uint_type other_uint_type; + static const int_type num_throwaway_bits = + static_cast(num_fraction_bits) - + static_cast(other_T::num_fraction_bits); + + static const uint_type last_significant_bit = + (num_throwaway_bits < 0) + ? 0 + : negatable_left_shift(num_throwaway_bits, 1u); + static const uint_type first_rounded_bit = + (num_throwaway_bits < 1) + ? 0 + : negatable_left_shift(num_throwaway_bits - 1, 1u); + + static const uint_type throwaway_mask_bits = + num_throwaway_bits > 0 ? num_throwaway_bits : 0; + static const uint_type throwaway_mask = + spvutils::SetBits::get; + + *carry_bit = false; + other_uint_type out_val = 0; + uint_type significand = getNormalizedSignificand(); + // If we are up-casting, then we just have to shift to the right location. + if (num_throwaway_bits <= 0) { + out_val = static_cast(significand); + uint_type shift_amount = static_cast(-num_throwaway_bits); + out_val = static_cast(out_val << shift_amount); + return out_val; + } + + // If every non-representable bit is 0, then we don't have any casting to + // do. + if ((significand & throwaway_mask) == 0) { + return static_cast( + negatable_right_shift(num_throwaway_bits, significand)); + } + + bool round_away_from_zero = false; + // We actually have to narrow the significand here, so we have to follow the + // rounding rules. + switch (dir) { + case kRoundToZero: + break; + case kRoundToPositiveInfinity: + round_away_from_zero = !isNegative(); + break; + case kRoundToNegativeInfinity: + round_away_from_zero = isNegative(); + break; + case kRoundToNearestEven: + // Have to round down, round bit is 0 + if ((first_rounded_bit & significand) == 0) { + break; + } + if (((significand & throwaway_mask) & ~first_rounded_bit) != 0) { + // If any subsequent bit of the rounded portion is non-0 then we round + // up. + round_away_from_zero = true; + break; + } + // We are exactly half-way between 2 numbers, pick even. + if ((significand & last_significant_bit) != 0) { + // 1 for our last bit, round up. + round_away_from_zero = true; + break; + } + break; + } + + if (round_away_from_zero) { + return static_cast( + negatable_right_shift(num_throwaway_bits, incrementSignificand( + significand, last_significant_bit, carry_bit))); + } else { + return static_cast( + negatable_right_shift(num_throwaway_bits, significand)); + } + } + + // Casts this value to another HexFloat. If the cast is widening, + // then round_dir is ignored. If the cast is narrowing, then + // the result is rounded in the direction specified. + // This number will retain Nan and Inf values. + // It will also saturate to Inf if the number overflows, and + // underflow to (0 or min depending on rounding) if the number underflows. + template + void castTo(other_T& other, round_direction round_dir) { + other = other_T(static_cast(0)); + bool negate = isNegative(); + if (getUnsignedBits() == 0) { + if (negate) { + other.set_value(-other.value()); + } + return; + } + uint_type significand = getSignificandBits(); + bool carried = false; + typename other_T::uint_type rounded_significand = + getRoundedNormalizedSignificand(round_dir, &carried); + + int_type exponent = getUnbiasedExponent(); + if (exponent == min_exponent) { + // If we are denormal, normalize the exponent, so that we can encode + // easily. + exponent = static_cast(exponent + 1); + for (uint_type check_bit = first_exponent_bit >> 1; check_bit != 0; + check_bit = static_cast(check_bit >> 1)) { + exponent = static_cast(exponent - 1); + if (check_bit & significand) break; + } + } + + bool is_nan = + (getBits() & exponent_mask) == exponent_mask && significand != 0; + bool is_inf = + !is_nan && + ((exponent + carried) > static_cast(other_T::exponent_bias) || + (significand == 0 && (getBits() & exponent_mask) == exponent_mask)); + + // If we are Nan or Inf we should pass that through. + if (is_inf) { + other.set_value(BitwiseCast( + static_cast( + (negate ? other_T::sign_mask : 0) | other_T::exponent_mask))); + return; + } + if (is_nan) { + typename other_T::uint_type shifted_significand; + shifted_significand = static_cast( + negatable_left_shift( + static_cast(other_T::num_fraction_bits) - + static_cast(num_fraction_bits), significand)); + + // We are some sort of Nan. We try to keep the bit-pattern of the Nan + // as close as possible. If we had to shift off bits so we are 0, then we + // just set the last bit. + other.set_value(BitwiseCast( + static_cast( + (negate ? other_T::sign_mask : 0) | other_T::exponent_mask | + (shifted_significand == 0 ? 0x1 : shifted_significand)))); + return; + } + + bool round_underflow_up = + isNegative() ? round_dir == kRoundToNegativeInfinity + : round_dir == kRoundToPositiveInfinity; + typedef typename other_T::int_type other_int_type; + // setFromSignUnbiasedExponentAndNormalizedSignificand will + // zero out any underflowing value (but retain the sign). + other.setFromSignUnbiasedExponentAndNormalizedSignificand( + negate, static_cast(exponent), rounded_significand, + round_underflow_up); + return; + } + + private: + T value_; + + static_assert(num_used_bits == + Traits::num_exponent_bits + Traits::num_fraction_bits + 1, + "The number of bits do not fit"); + static_assert(sizeof(T) == sizeof(uint_type), "The type sizes do not match"); +}; + +// Returns 4 bits represented by the hex character. +inline uint8_t get_nibble_from_character(int character) { + const char* dec = "0123456789"; + const char* lower = "abcdef"; + const char* upper = "ABCDEF"; + const char* p = nullptr; + if ((p = strchr(dec, character))) { + return static_cast(p - dec); + } else if ((p = strchr(lower, character))) { + return static_cast(p - lower + 0xa); + } else if ((p = strchr(upper, character))) { + return static_cast(p - upper + 0xa); + } + + assert(false && "This was called with a non-hex character"); + return 0; +} + +// Outputs the given HexFloat to the stream. +template +std::ostream& operator<<(std::ostream& os, const HexFloat& value) { + typedef HexFloat HF; + typedef typename HF::uint_type uint_type; + typedef typename HF::int_type int_type; + + static_assert(HF::num_used_bits != 0, + "num_used_bits must be non-zero for a valid float"); + static_assert(HF::num_exponent_bits != 0, + "num_exponent_bits must be non-zero for a valid float"); + static_assert(HF::num_fraction_bits != 0, + "num_fractin_bits must be non-zero for a valid float"); + + const uint_type bits = spvutils::BitwiseCast(value.value()); + const char* const sign = (bits & HF::sign_mask) ? "-" : ""; + const uint_type exponent = static_cast( + (bits & HF::exponent_mask) >> HF::num_fraction_bits); + + uint_type fraction = static_cast((bits & HF::fraction_encode_mask) + << HF::num_overflow_bits); + + const bool is_zero = exponent == 0 && fraction == 0; + const bool is_denorm = exponent == 0 && !is_zero; + + // exponent contains the biased exponent we have to convert it back into + // the normal range. + int_type int_exponent = static_cast(exponent - HF::exponent_bias); + // If the number is all zeros, then we actually have to NOT shift the + // exponent. + int_exponent = is_zero ? 0 : int_exponent; + + // If we are denorm, then start shifting, and decreasing the exponent until + // our leading bit is 1. + + if (is_denorm) { + while ((fraction & HF::fraction_top_bit) == 0) { + fraction = static_cast(fraction << 1); + int_exponent = static_cast(int_exponent - 1); + } + // Since this is denormalized, we have to consume the leading 1 since it + // will end up being implicit. + fraction = static_cast(fraction << 1); // eat the leading 1 + fraction &= HF::fraction_represent_mask; + } + + uint_type fraction_nibbles = HF::fraction_nibbles; + // We do not have to display any trailing 0s, since this represents the + // fractional part. + while (fraction_nibbles > 0 && (fraction & 0xF) == 0) { + // Shift off any trailing values; + fraction = static_cast(fraction >> 4); + --fraction_nibbles; + } + + const auto saved_flags = os.flags(); + const auto saved_fill = os.fill(); + + os << sign << "0x" << (is_zero ? '0' : '1'); + if (fraction_nibbles) { + // Make sure to keep the leading 0s in place, since this is the fractional + // part. + os << "." << std::setw(static_cast(fraction_nibbles)) + << std::setfill('0') << std::hex << fraction; + } + os << "p" << std::dec << (int_exponent >= 0 ? "+" : "") << int_exponent; + + os.flags(saved_flags); + os.fill(saved_fill); + + return os; +} + +// Returns true if negate_value is true and the next character on the +// input stream is a plus or minus sign. In that case we also set the fail bit +// on the stream and set the value to the zero value for its type. +template +inline bool RejectParseDueToLeadingSign(std::istream& is, bool negate_value, + HexFloat& value) { + if (negate_value) { + auto next_char = is.peek(); + if (next_char == '-' || next_char == '+') { + // Fail the parse. Emulate standard behaviour by setting the value to + // the zero value, and set the fail bit on the stream. + value = HexFloat(typename HexFloat::uint_type(0)); + is.setstate(std::ios_base::failbit); + return true; + } + } + return false; +} + +// Parses a floating point number from the given stream and stores it into the +// value parameter. +// If negate_value is true then the number may not have a leading minus or +// plus, and if it successfully parses, then the number is negated before +// being stored into the value parameter. +// If the value cannot be correctly parsed or overflows the target floating +// point type, then set the fail bit on the stream. +// TODO(dneto): Promise C++11 standard behavior in how the value is set in +// the error case, but only after all target platforms implement it correctly. +// In particular, the Microsoft C++ runtime appears to be out of spec. +template +inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value, + HexFloat& value) { + if (RejectParseDueToLeadingSign(is, negate_value, value)) { + return is; + } + T val; + is >> val; + if (negate_value) { + val = -val; + } + value.set_value(val); + // In the failure case, map -0.0 to 0.0. + if (is.fail() && value.getUnsignedBits() == 0u) { + value = HexFloat(typename HexFloat::uint_type(0)); + } + if (val.isInfinity()) { + // Fail the parse. Emulate standard behaviour by setting the value to + // the closest normal value, and set the fail bit on the stream. + value.set_value((value.isNegative() || negate_value) ? T::lowest() + : T::max()); + is.setstate(std::ios_base::failbit); + } + return is; +} + +// Specialization of ParseNormalFloat for FloatProxy values. +// This will parse the float as it were a 32-bit floating point number, +// and then round it down to fit into a Float16 value. +// The number is rounded towards zero. +// If negate_value is true then the number may not have a leading minus or +// plus, and if it successfully parses, then the number is negated before +// being stored into the value parameter. +// If the value cannot be correctly parsed or overflows the target floating +// point type, then set the fail bit on the stream. +// TODO(dneto): Promise C++11 standard behavior in how the value is set in +// the error case, but only after all target platforms implement it correctly. +// In particular, the Microsoft C++ runtime appears to be out of spec. +template <> +inline std::istream& +ParseNormalFloat, HexFloatTraits>>( + std::istream& is, bool negate_value, + HexFloat, HexFloatTraits>>& value) { + // First parse as a 32-bit float. + HexFloat> float_val(0.0f); + ParseNormalFloat(is, negate_value, float_val); + + // Then convert to 16-bit float, saturating at infinities, and + // rounding toward zero. + float_val.castTo(value, kRoundToZero); + + // Overflow on 16-bit behaves the same as for 32- and 64-bit: set the + // fail bit and set the lowest or highest value. + if (Float16::isInfinity(value.value().getAsFloat())) { + value.set_value(value.isNegative() ? Float16::lowest() : Float16::max()); + is.setstate(std::ios_base::failbit); + } + return is; +} + +// Reads a HexFloat from the given stream. +// If the float is not encoded as a hex-float then it will be parsed +// as a regular float. +// This may fail if your stream does not support at least one unget. +// Nan values can be encoded with "0x1.p+exponent_bias". +// This would normally overflow a float and round to +// infinity but this special pattern is the exact representation for a NaN, +// and therefore is actually encoded as the correct NaN. To encode inf, +// either 0x0p+exponent_bias can be specified or any exponent greater than +// exponent_bias. +// Examples using IEEE 32-bit float encoding. +// 0x1.0p+128 (+inf) +// -0x1.0p-128 (-inf) +// +// 0x1.1p+128 (+Nan) +// -0x1.1p+128 (-Nan) +// +// 0x1p+129 (+inf) +// -0x1p+129 (-inf) +template +std::istream& operator>>(std::istream& is, HexFloat& value) { + using HF = HexFloat; + using uint_type = typename HF::uint_type; + using int_type = typename HF::int_type; + + value.set_value(static_cast(0.f)); + + if (is.flags() & std::ios::skipws) { + // If the user wants to skip whitespace , then we should obey that. + while (std::isspace(is.peek())) { + is.get(); + } + } + + auto next_char = is.peek(); + bool negate_value = false; + + if (next_char != '-' && next_char != '0') { + return ParseNormalFloat(is, negate_value, value); + } + + if (next_char == '-') { + negate_value = true; + is.get(); + next_char = is.peek(); + } + + if (next_char == '0') { + is.get(); // We may have to unget this. + auto maybe_hex_start = is.peek(); + if (maybe_hex_start != 'x' && maybe_hex_start != 'X') { + is.unget(); + return ParseNormalFloat(is, negate_value, value); + } else { + is.get(); // Throw away the 'x'; + } + } else { + return ParseNormalFloat(is, negate_value, value); + } + + // This "looks" like a hex-float so treat it as one. + bool seen_p = false; + bool seen_dot = false; + uint_type fraction_index = 0; + + uint_type fraction = 0; + int_type exponent = HF::exponent_bias; + + // Strip off leading zeros so we don't have to special-case them later. + while ((next_char = is.peek()) == '0') { + is.get(); + } + + bool is_denorm = + true; // Assume denorm "representation" until we hear otherwise. + // NB: This does not mean the value is actually denorm, + // it just means that it was written 0. + bool bits_written = false; // Stays false until we write a bit. + while (!seen_p && !seen_dot) { + // Handle characters that are left of the fractional part. + if (next_char == '.') { + seen_dot = true; + } else if (next_char == 'p') { + seen_p = true; + } else if (::isxdigit(next_char)) { + // We know this is not denormalized since we have stripped all leading + // zeroes and we are not a ".". + is_denorm = false; + int number = get_nibble_from_character(next_char); + for (int i = 0; i < 4; ++i, number <<= 1) { + uint_type write_bit = (number & 0x8) ? 0x1 : 0x0; + if (bits_written) { + // If we are here the bits represented belong in the fractional + // part of the float, and we have to adjust the exponent accordingly. + fraction = static_cast( + fraction | + static_cast( + write_bit << (HF::top_bit_left_shift - fraction_index++))); + exponent = static_cast(exponent + 1); + } + bits_written |= write_bit != 0; + } + } else { + // We have not found our exponent yet, so we have to fail. + is.setstate(std::ios::failbit); + return is; + } + is.get(); + next_char = is.peek(); + } + bits_written = false; + while (seen_dot && !seen_p) { + // Handle only fractional parts now. + if (next_char == 'p') { + seen_p = true; + } else if (::isxdigit(next_char)) { + int number = get_nibble_from_character(next_char); + for (int i = 0; i < 4; ++i, number <<= 1) { + uint_type write_bit = (number & 0x8) ? 0x01 : 0x00; + bits_written |= write_bit != 0; + if (is_denorm && !bits_written) { + // Handle modifying the exponent here this way we can handle + // an arbitrary number of hex values without overflowing our + // integer. + exponent = static_cast(exponent - 1); + } else { + fraction = static_cast( + fraction | + static_cast( + write_bit << (HF::top_bit_left_shift - fraction_index++))); + } + } + } else { + // We still have not found our 'p' exponent yet, so this is not a valid + // hex-float. + is.setstate(std::ios::failbit); + return is; + } + is.get(); + next_char = is.peek(); + } + + bool seen_sign = false; + int8_t exponent_sign = 1; + int_type written_exponent = 0; + while (true) { + if ((next_char == '-' || next_char == '+')) { + if (seen_sign) { + is.setstate(std::ios::failbit); + return is; + } + seen_sign = true; + exponent_sign = (next_char == '-') ? -1 : 1; + } else if (::isdigit(next_char)) { + // Hex-floats express their exponent as decimal. + written_exponent = static_cast(written_exponent * 10); + written_exponent = + static_cast(written_exponent + (next_char - '0')); + } else { + break; + } + is.get(); + next_char = is.peek(); + } + + written_exponent = static_cast(written_exponent * exponent_sign); + exponent = static_cast(exponent + written_exponent); + + bool is_zero = is_denorm && (fraction == 0); + if (is_denorm && !is_zero) { + fraction = static_cast(fraction << 1); + exponent = static_cast(exponent - 1); + } else if (is_zero) { + exponent = 0; + } + + if (exponent <= 0 && !is_zero) { + fraction = static_cast(fraction >> 1); + fraction |= static_cast(1) << HF::top_bit_left_shift; + } + + fraction = (fraction >> HF::fraction_right_shift) & HF::fraction_encode_mask; + + const int_type max_exponent = + SetBits::get; + + // Handle actual denorm numbers + while (exponent < 0 && !is_zero) { + fraction = static_cast(fraction >> 1); + exponent = static_cast(exponent + 1); + + fraction &= HF::fraction_encode_mask; + if (fraction == 0) { + // We have underflowed our fraction. We should clamp to zero. + is_zero = true; + exponent = 0; + } + } + + // We have overflowed so we should be inf/-inf. + if (exponent > max_exponent) { + exponent = max_exponent; + fraction = 0; + } + + uint_type output_bits = static_cast( + static_cast(negate_value ? 1 : 0) << HF::top_bit_left_shift); + output_bits |= fraction; + + uint_type shifted_exponent = static_cast( + static_cast(exponent << HF::exponent_left_shift) & + HF::exponent_mask); + output_bits |= shifted_exponent; + + T output_float = spvutils::BitwiseCast(output_bits); + value.set_value(output_float); + + return is; +} + +// Writes a FloatProxy value to a stream. +// Zero and normal numbers are printed in the usual notation, but with +// enough digits to fully reproduce the value. Other values (subnormal, +// NaN, and infinity) are printed as a hex float. +template +std::ostream& operator<<(std::ostream& os, const FloatProxy& value) { + auto float_val = value.getAsFloat(); + switch (std::fpclassify(float_val)) { + case FP_ZERO: + case FP_NORMAL: { + auto saved_precision = os.precision(); + os.precision(std::numeric_limits::digits10); + os << float_val; + os.precision(saved_precision); + } break; + default: + os << HexFloat>(value); + break; + } + return os; +} + +template <> +inline std::ostream& operator<<(std::ostream& os, + const FloatProxy& value) { + os << HexFloat>(value); + return os; +} +} + +#endif // LIBSPIRV_UTIL_HEX_FLOAT_H_ diff --git a/android/x86_64/include/glslang/SPIRV/spirv.hpp b/android/x86_64/include/glslang/SPIRV/spirv.hpp new file mode 100644 index 00000000..dae36cf2 --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/spirv.hpp @@ -0,0 +1,2114 @@ +// Copyright (c) 2014-2020 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 header is automatically generated by the same tool that creates +// the Binary Section of the SPIR-V specification. + +// Enumeration tokens for SPIR-V, in various styles: +// C, C++, C++11, JSON, Lua, Python, C#, D +// +// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL +// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL +// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL +// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL +// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL'] +// - C# will use enum classes in the Specification class located in the "Spv" namespace, +// e.g.: Spv.Specification.SourceLanguage.GLSL +// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL +// +// Some tokens act like mask values, which can be OR'd together, +// while others are mutually exclusive. The mask-like ones have +// "Mask" in their name, and a parallel enum that has the shift +// amount (1 << x) for each corresponding enumerant. + +#ifndef spirv_HPP +#define spirv_HPP + +namespace spv { + +typedef unsigned int Id; + +#define SPV_VERSION 0x10500 +#define SPV_REVISION 3 + +static const unsigned int MagicNumber = 0x07230203; +static const unsigned int Version = 0x00010500; +static const unsigned int Revision = 3; +static const unsigned int OpCodeMask = 0xffff; +static const unsigned int WordCountShift = 16; + +enum SourceLanguage { + SourceLanguageUnknown = 0, + SourceLanguageESSL = 1, + SourceLanguageGLSL = 2, + SourceLanguageOpenCL_C = 3, + SourceLanguageOpenCL_CPP = 4, + SourceLanguageHLSL = 5, + SourceLanguageMax = 0x7fffffff, +}; + +enum ExecutionModel { + ExecutionModelVertex = 0, + ExecutionModelTessellationControl = 1, + ExecutionModelTessellationEvaluation = 2, + ExecutionModelGeometry = 3, + ExecutionModelFragment = 4, + ExecutionModelGLCompute = 5, + ExecutionModelKernel = 6, + ExecutionModelTaskNV = 5267, + ExecutionModelMeshNV = 5268, + ExecutionModelRayGenerationKHR = 5313, + ExecutionModelRayGenerationNV = 5313, + ExecutionModelIntersectionKHR = 5314, + ExecutionModelIntersectionNV = 5314, + ExecutionModelAnyHitKHR = 5315, + ExecutionModelAnyHitNV = 5315, + ExecutionModelClosestHitKHR = 5316, + ExecutionModelClosestHitNV = 5316, + ExecutionModelMissKHR = 5317, + ExecutionModelMissNV = 5317, + ExecutionModelCallableKHR = 5318, + ExecutionModelCallableNV = 5318, + ExecutionModelMax = 0x7fffffff, +}; + +enum AddressingModel { + AddressingModelLogical = 0, + AddressingModelPhysical32 = 1, + AddressingModelPhysical64 = 2, + AddressingModelPhysicalStorageBuffer64 = 5348, + AddressingModelPhysicalStorageBuffer64EXT = 5348, + AddressingModelMax = 0x7fffffff, +}; + +enum MemoryModel { + MemoryModelSimple = 0, + MemoryModelGLSL450 = 1, + MemoryModelOpenCL = 2, + MemoryModelVulkan = 3, + MemoryModelVulkanKHR = 3, + MemoryModelMax = 0x7fffffff, +}; + +enum ExecutionMode { + ExecutionModeInvocations = 0, + ExecutionModeSpacingEqual = 1, + ExecutionModeSpacingFractionalEven = 2, + ExecutionModeSpacingFractionalOdd = 3, + ExecutionModeVertexOrderCw = 4, + ExecutionModeVertexOrderCcw = 5, + ExecutionModePixelCenterInteger = 6, + ExecutionModeOriginUpperLeft = 7, + ExecutionModeOriginLowerLeft = 8, + ExecutionModeEarlyFragmentTests = 9, + ExecutionModePointMode = 10, + ExecutionModeXfb = 11, + ExecutionModeDepthReplacing = 12, + ExecutionModeDepthGreater = 14, + ExecutionModeDepthLess = 15, + ExecutionModeDepthUnchanged = 16, + ExecutionModeLocalSize = 17, + ExecutionModeLocalSizeHint = 18, + ExecutionModeInputPoints = 19, + ExecutionModeInputLines = 20, + ExecutionModeInputLinesAdjacency = 21, + ExecutionModeTriangles = 22, + ExecutionModeInputTrianglesAdjacency = 23, + ExecutionModeQuads = 24, + ExecutionModeIsolines = 25, + ExecutionModeOutputVertices = 26, + ExecutionModeOutputPoints = 27, + ExecutionModeOutputLineStrip = 28, + ExecutionModeOutputTriangleStrip = 29, + ExecutionModeVecTypeHint = 30, + ExecutionModeContractionOff = 31, + ExecutionModeInitializer = 33, + ExecutionModeFinalizer = 34, + ExecutionModeSubgroupSize = 35, + ExecutionModeSubgroupsPerWorkgroup = 36, + ExecutionModeSubgroupsPerWorkgroupId = 37, + ExecutionModeLocalSizeId = 38, + ExecutionModeLocalSizeHintId = 39, + ExecutionModePostDepthCoverage = 4446, + ExecutionModeDenormPreserve = 4459, + ExecutionModeDenormFlushToZero = 4460, + ExecutionModeSignedZeroInfNanPreserve = 4461, + ExecutionModeRoundingModeRTE = 4462, + ExecutionModeRoundingModeRTZ = 4463, + ExecutionModeStencilRefReplacingEXT = 5027, + ExecutionModeOutputLinesNV = 5269, + ExecutionModeOutputPrimitivesNV = 5270, + ExecutionModeDerivativeGroupQuadsNV = 5289, + ExecutionModeDerivativeGroupLinearNV = 5290, + ExecutionModeOutputTrianglesNV = 5298, + ExecutionModePixelInterlockOrderedEXT = 5366, + ExecutionModePixelInterlockUnorderedEXT = 5367, + ExecutionModeSampleInterlockOrderedEXT = 5368, + ExecutionModeSampleInterlockUnorderedEXT = 5369, + ExecutionModeShadingRateInterlockOrderedEXT = 5370, + ExecutionModeShadingRateInterlockUnorderedEXT = 5371, + ExecutionModeMax = 0x7fffffff, +}; + +enum StorageClass { + StorageClassUniformConstant = 0, + StorageClassInput = 1, + StorageClassUniform = 2, + StorageClassOutput = 3, + StorageClassWorkgroup = 4, + StorageClassCrossWorkgroup = 5, + StorageClassPrivate = 6, + StorageClassFunction = 7, + StorageClassGeneric = 8, + StorageClassPushConstant = 9, + StorageClassAtomicCounter = 10, + StorageClassImage = 11, + StorageClassStorageBuffer = 12, + StorageClassCallableDataKHR = 5328, + StorageClassCallableDataNV = 5328, + StorageClassIncomingCallableDataKHR = 5329, + StorageClassIncomingCallableDataNV = 5329, + StorageClassRayPayloadKHR = 5338, + StorageClassRayPayloadNV = 5338, + StorageClassHitAttributeKHR = 5339, + StorageClassHitAttributeNV = 5339, + StorageClassIncomingRayPayloadKHR = 5342, + StorageClassIncomingRayPayloadNV = 5342, + StorageClassShaderRecordBufferKHR = 5343, + StorageClassShaderRecordBufferNV = 5343, + StorageClassPhysicalStorageBuffer = 5349, + StorageClassPhysicalStorageBufferEXT = 5349, + StorageClassMax = 0x7fffffff, +}; + +enum Dim { + Dim1D = 0, + Dim2D = 1, + Dim3D = 2, + DimCube = 3, + DimRect = 4, + DimBuffer = 5, + DimSubpassData = 6, + DimMax = 0x7fffffff, +}; + +enum SamplerAddressingMode { + SamplerAddressingModeNone = 0, + SamplerAddressingModeClampToEdge = 1, + SamplerAddressingModeClamp = 2, + SamplerAddressingModeRepeat = 3, + SamplerAddressingModeRepeatMirrored = 4, + SamplerAddressingModeMax = 0x7fffffff, +}; + +enum SamplerFilterMode { + SamplerFilterModeNearest = 0, + SamplerFilterModeLinear = 1, + SamplerFilterModeMax = 0x7fffffff, +}; + +enum ImageFormat { + ImageFormatUnknown = 0, + ImageFormatRgba32f = 1, + ImageFormatRgba16f = 2, + ImageFormatR32f = 3, + ImageFormatRgba8 = 4, + ImageFormatRgba8Snorm = 5, + ImageFormatRg32f = 6, + ImageFormatRg16f = 7, + ImageFormatR11fG11fB10f = 8, + ImageFormatR16f = 9, + ImageFormatRgba16 = 10, + ImageFormatRgb10A2 = 11, + ImageFormatRg16 = 12, + ImageFormatRg8 = 13, + ImageFormatR16 = 14, + ImageFormatR8 = 15, + ImageFormatRgba16Snorm = 16, + ImageFormatRg16Snorm = 17, + ImageFormatRg8Snorm = 18, + ImageFormatR16Snorm = 19, + ImageFormatR8Snorm = 20, + ImageFormatRgba32i = 21, + ImageFormatRgba16i = 22, + ImageFormatRgba8i = 23, + ImageFormatR32i = 24, + ImageFormatRg32i = 25, + ImageFormatRg16i = 26, + ImageFormatRg8i = 27, + ImageFormatR16i = 28, + ImageFormatR8i = 29, + ImageFormatRgba32ui = 30, + ImageFormatRgba16ui = 31, + ImageFormatRgba8ui = 32, + ImageFormatR32ui = 33, + ImageFormatRgb10a2ui = 34, + ImageFormatRg32ui = 35, + ImageFormatRg16ui = 36, + ImageFormatRg8ui = 37, + ImageFormatR16ui = 38, + ImageFormatR8ui = 39, + ImageFormatMax = 0x7fffffff, +}; + +enum ImageChannelOrder { + ImageChannelOrderR = 0, + ImageChannelOrderA = 1, + ImageChannelOrderRG = 2, + ImageChannelOrderRA = 3, + ImageChannelOrderRGB = 4, + ImageChannelOrderRGBA = 5, + ImageChannelOrderBGRA = 6, + ImageChannelOrderARGB = 7, + ImageChannelOrderIntensity = 8, + ImageChannelOrderLuminance = 9, + ImageChannelOrderRx = 10, + ImageChannelOrderRGx = 11, + ImageChannelOrderRGBx = 12, + ImageChannelOrderDepth = 13, + ImageChannelOrderDepthStencil = 14, + ImageChannelOrdersRGB = 15, + ImageChannelOrdersRGBx = 16, + ImageChannelOrdersRGBA = 17, + ImageChannelOrdersBGRA = 18, + ImageChannelOrderABGR = 19, + ImageChannelOrderMax = 0x7fffffff, +}; + +enum ImageChannelDataType { + ImageChannelDataTypeSnormInt8 = 0, + ImageChannelDataTypeSnormInt16 = 1, + ImageChannelDataTypeUnormInt8 = 2, + ImageChannelDataTypeUnormInt16 = 3, + ImageChannelDataTypeUnormShort565 = 4, + ImageChannelDataTypeUnormShort555 = 5, + ImageChannelDataTypeUnormInt101010 = 6, + ImageChannelDataTypeSignedInt8 = 7, + ImageChannelDataTypeSignedInt16 = 8, + ImageChannelDataTypeSignedInt32 = 9, + ImageChannelDataTypeUnsignedInt8 = 10, + ImageChannelDataTypeUnsignedInt16 = 11, + ImageChannelDataTypeUnsignedInt32 = 12, + ImageChannelDataTypeHalfFloat = 13, + ImageChannelDataTypeFloat = 14, + ImageChannelDataTypeUnormInt24 = 15, + ImageChannelDataTypeUnormInt101010_2 = 16, + ImageChannelDataTypeMax = 0x7fffffff, +}; + +enum ImageOperandsShift { + ImageOperandsBiasShift = 0, + ImageOperandsLodShift = 1, + ImageOperandsGradShift = 2, + ImageOperandsConstOffsetShift = 3, + ImageOperandsOffsetShift = 4, + ImageOperandsConstOffsetsShift = 5, + ImageOperandsSampleShift = 6, + ImageOperandsMinLodShift = 7, + ImageOperandsMakeTexelAvailableShift = 8, + ImageOperandsMakeTexelAvailableKHRShift = 8, + ImageOperandsMakeTexelVisibleShift = 9, + ImageOperandsMakeTexelVisibleKHRShift = 9, + ImageOperandsNonPrivateTexelShift = 10, + ImageOperandsNonPrivateTexelKHRShift = 10, + ImageOperandsVolatileTexelShift = 11, + ImageOperandsVolatileTexelKHRShift = 11, + ImageOperandsSignExtendShift = 12, + ImageOperandsZeroExtendShift = 13, + ImageOperandsMax = 0x7fffffff, +}; + +enum ImageOperandsMask { + ImageOperandsMaskNone = 0, + ImageOperandsBiasMask = 0x00000001, + ImageOperandsLodMask = 0x00000002, + ImageOperandsGradMask = 0x00000004, + ImageOperandsConstOffsetMask = 0x00000008, + ImageOperandsOffsetMask = 0x00000010, + ImageOperandsConstOffsetsMask = 0x00000020, + ImageOperandsSampleMask = 0x00000040, + ImageOperandsMinLodMask = 0x00000080, + ImageOperandsMakeTexelAvailableMask = 0x00000100, + ImageOperandsMakeTexelAvailableKHRMask = 0x00000100, + ImageOperandsMakeTexelVisibleMask = 0x00000200, + ImageOperandsMakeTexelVisibleKHRMask = 0x00000200, + ImageOperandsNonPrivateTexelMask = 0x00000400, + ImageOperandsNonPrivateTexelKHRMask = 0x00000400, + ImageOperandsVolatileTexelMask = 0x00000800, + ImageOperandsVolatileTexelKHRMask = 0x00000800, + ImageOperandsSignExtendMask = 0x00001000, + ImageOperandsZeroExtendMask = 0x00002000, +}; + +enum FPFastMathModeShift { + FPFastMathModeNotNaNShift = 0, + FPFastMathModeNotInfShift = 1, + FPFastMathModeNSZShift = 2, + FPFastMathModeAllowRecipShift = 3, + FPFastMathModeFastShift = 4, + FPFastMathModeMax = 0x7fffffff, +}; + +enum FPFastMathModeMask { + FPFastMathModeMaskNone = 0, + FPFastMathModeNotNaNMask = 0x00000001, + FPFastMathModeNotInfMask = 0x00000002, + FPFastMathModeNSZMask = 0x00000004, + FPFastMathModeAllowRecipMask = 0x00000008, + FPFastMathModeFastMask = 0x00000010, +}; + +enum FPRoundingMode { + FPRoundingModeRTE = 0, + FPRoundingModeRTZ = 1, + FPRoundingModeRTP = 2, + FPRoundingModeRTN = 3, + FPRoundingModeMax = 0x7fffffff, +}; + +enum LinkageType { + LinkageTypeExport = 0, + LinkageTypeImport = 1, + LinkageTypeMax = 0x7fffffff, +}; + +enum AccessQualifier { + AccessQualifierReadOnly = 0, + AccessQualifierWriteOnly = 1, + AccessQualifierReadWrite = 2, + AccessQualifierMax = 0x7fffffff, +}; + +enum FunctionParameterAttribute { + FunctionParameterAttributeZext = 0, + FunctionParameterAttributeSext = 1, + FunctionParameterAttributeByVal = 2, + FunctionParameterAttributeSret = 3, + FunctionParameterAttributeNoAlias = 4, + FunctionParameterAttributeNoCapture = 5, + FunctionParameterAttributeNoWrite = 6, + FunctionParameterAttributeNoReadWrite = 7, + FunctionParameterAttributeMax = 0x7fffffff, +}; + +enum Decoration { + DecorationRelaxedPrecision = 0, + DecorationSpecId = 1, + DecorationBlock = 2, + DecorationBufferBlock = 3, + DecorationRowMajor = 4, + DecorationColMajor = 5, + DecorationArrayStride = 6, + DecorationMatrixStride = 7, + DecorationGLSLShared = 8, + DecorationGLSLPacked = 9, + DecorationCPacked = 10, + DecorationBuiltIn = 11, + DecorationNoPerspective = 13, + DecorationFlat = 14, + DecorationPatch = 15, + DecorationCentroid = 16, + DecorationSample = 17, + DecorationInvariant = 18, + DecorationRestrict = 19, + DecorationAliased = 20, + DecorationVolatile = 21, + DecorationConstant = 22, + DecorationCoherent = 23, + DecorationNonWritable = 24, + DecorationNonReadable = 25, + DecorationUniform = 26, + DecorationUniformId = 27, + DecorationSaturatedConversion = 28, + DecorationStream = 29, + DecorationLocation = 30, + DecorationComponent = 31, + DecorationIndex = 32, + DecorationBinding = 33, + DecorationDescriptorSet = 34, + DecorationOffset = 35, + DecorationXfbBuffer = 36, + DecorationXfbStride = 37, + DecorationFuncParamAttr = 38, + DecorationFPRoundingMode = 39, + DecorationFPFastMathMode = 40, + DecorationLinkageAttributes = 41, + DecorationNoContraction = 42, + DecorationInputAttachmentIndex = 43, + DecorationAlignment = 44, + DecorationMaxByteOffset = 45, + DecorationAlignmentId = 46, + DecorationMaxByteOffsetId = 47, + DecorationNoSignedWrap = 4469, + DecorationNoUnsignedWrap = 4470, + DecorationExplicitInterpAMD = 4999, + DecorationOverrideCoverageNV = 5248, + DecorationPassthroughNV = 5250, + DecorationViewportRelativeNV = 5252, + DecorationSecondaryViewportRelativeNV = 5256, + DecorationPerPrimitiveNV = 5271, + DecorationPerViewNV = 5272, + DecorationPerTaskNV = 5273, + DecorationPerVertexNV = 5285, + DecorationNonUniform = 5300, + DecorationNonUniformEXT = 5300, + DecorationRestrictPointer = 5355, + DecorationRestrictPointerEXT = 5355, + DecorationAliasedPointer = 5356, + DecorationAliasedPointerEXT = 5356, + DecorationCounterBuffer = 5634, + DecorationHlslCounterBufferGOOGLE = 5634, + DecorationHlslSemanticGOOGLE = 5635, + DecorationUserSemantic = 5635, + DecorationUserTypeGOOGLE = 5636, + DecorationMax = 0x7fffffff, +}; + +enum BuiltIn { + BuiltInPosition = 0, + BuiltInPointSize = 1, + BuiltInClipDistance = 3, + BuiltInCullDistance = 4, + BuiltInVertexId = 5, + BuiltInInstanceId = 6, + BuiltInPrimitiveId = 7, + BuiltInInvocationId = 8, + BuiltInLayer = 9, + BuiltInViewportIndex = 10, + BuiltInTessLevelOuter = 11, + BuiltInTessLevelInner = 12, + BuiltInTessCoord = 13, + BuiltInPatchVertices = 14, + BuiltInFragCoord = 15, + BuiltInPointCoord = 16, + BuiltInFrontFacing = 17, + BuiltInSampleId = 18, + BuiltInSamplePosition = 19, + BuiltInSampleMask = 20, + BuiltInFragDepth = 22, + BuiltInHelperInvocation = 23, + BuiltInNumWorkgroups = 24, + BuiltInWorkgroupSize = 25, + BuiltInWorkgroupId = 26, + BuiltInLocalInvocationId = 27, + BuiltInGlobalInvocationId = 28, + BuiltInLocalInvocationIndex = 29, + BuiltInWorkDim = 30, + BuiltInGlobalSize = 31, + BuiltInEnqueuedWorkgroupSize = 32, + BuiltInGlobalOffset = 33, + BuiltInGlobalLinearId = 34, + BuiltInSubgroupSize = 36, + BuiltInSubgroupMaxSize = 37, + BuiltInNumSubgroups = 38, + BuiltInNumEnqueuedSubgroups = 39, + BuiltInSubgroupId = 40, + BuiltInSubgroupLocalInvocationId = 41, + BuiltInVertexIndex = 42, + BuiltInInstanceIndex = 43, + BuiltInSubgroupEqMask = 4416, + BuiltInSubgroupEqMaskKHR = 4416, + BuiltInSubgroupGeMask = 4417, + BuiltInSubgroupGeMaskKHR = 4417, + BuiltInSubgroupGtMask = 4418, + BuiltInSubgroupGtMaskKHR = 4418, + BuiltInSubgroupLeMask = 4419, + BuiltInSubgroupLeMaskKHR = 4419, + BuiltInSubgroupLtMask = 4420, + BuiltInSubgroupLtMaskKHR = 4420, + BuiltInBaseVertex = 4424, + BuiltInBaseInstance = 4425, + BuiltInDrawIndex = 4426, + BuiltInDeviceIndex = 4438, + BuiltInViewIndex = 4440, + BuiltInBaryCoordNoPerspAMD = 4992, + BuiltInBaryCoordNoPerspCentroidAMD = 4993, + BuiltInBaryCoordNoPerspSampleAMD = 4994, + BuiltInBaryCoordSmoothAMD = 4995, + BuiltInBaryCoordSmoothCentroidAMD = 4996, + BuiltInBaryCoordSmoothSampleAMD = 4997, + BuiltInBaryCoordPullModelAMD = 4998, + BuiltInFragStencilRefEXT = 5014, + BuiltInViewportMaskNV = 5253, + BuiltInSecondaryPositionNV = 5257, + BuiltInSecondaryViewportMaskNV = 5258, + BuiltInPositionPerViewNV = 5261, + BuiltInViewportMaskPerViewNV = 5262, + BuiltInFullyCoveredEXT = 5264, + BuiltInTaskCountNV = 5274, + BuiltInPrimitiveCountNV = 5275, + BuiltInPrimitiveIndicesNV = 5276, + BuiltInClipDistancePerViewNV = 5277, + BuiltInCullDistancePerViewNV = 5278, + BuiltInLayerPerViewNV = 5279, + BuiltInMeshViewCountNV = 5280, + BuiltInMeshViewIndicesNV = 5281, + BuiltInBaryCoordNV = 5286, + BuiltInBaryCoordNoPerspNV = 5287, + BuiltInFragSizeEXT = 5292, + BuiltInFragmentSizeNV = 5292, + BuiltInFragInvocationCountEXT = 5293, + BuiltInInvocationsPerPixelNV = 5293, + BuiltInLaunchIdKHR = 5319, + BuiltInLaunchIdNV = 5319, + BuiltInLaunchSizeKHR = 5320, + BuiltInLaunchSizeNV = 5320, + BuiltInWorldRayOriginKHR = 5321, + BuiltInWorldRayOriginNV = 5321, + BuiltInWorldRayDirectionKHR = 5322, + BuiltInWorldRayDirectionNV = 5322, + BuiltInObjectRayOriginKHR = 5323, + BuiltInObjectRayOriginNV = 5323, + BuiltInObjectRayDirectionKHR = 5324, + BuiltInObjectRayDirectionNV = 5324, + BuiltInRayTminKHR = 5325, + BuiltInRayTminNV = 5325, + BuiltInRayTmaxKHR = 5326, + BuiltInRayTmaxNV = 5326, + BuiltInInstanceCustomIndexKHR = 5327, + BuiltInInstanceCustomIndexNV = 5327, + BuiltInObjectToWorldKHR = 5330, + BuiltInObjectToWorldNV = 5330, + BuiltInWorldToObjectKHR = 5331, + BuiltInWorldToObjectNV = 5331, + BuiltInHitTKHR = 5332, + BuiltInHitTNV = 5332, + BuiltInHitKindKHR = 5333, + BuiltInHitKindNV = 5333, + BuiltInIncomingRayFlagsKHR = 5351, + BuiltInIncomingRayFlagsNV = 5351, + BuiltInRayGeometryIndexKHR = 5352, + BuiltInWarpsPerSMNV = 5374, + BuiltInSMCountNV = 5375, + BuiltInWarpIDNV = 5376, + BuiltInSMIDNV = 5377, + BuiltInMax = 0x7fffffff, +}; + +enum SelectionControlShift { + SelectionControlFlattenShift = 0, + SelectionControlDontFlattenShift = 1, + SelectionControlMax = 0x7fffffff, +}; + +enum SelectionControlMask { + SelectionControlMaskNone = 0, + SelectionControlFlattenMask = 0x00000001, + SelectionControlDontFlattenMask = 0x00000002, +}; + +enum LoopControlShift { + LoopControlUnrollShift = 0, + LoopControlDontUnrollShift = 1, + LoopControlDependencyInfiniteShift = 2, + LoopControlDependencyLengthShift = 3, + LoopControlMinIterationsShift = 4, + LoopControlMaxIterationsShift = 5, + LoopControlIterationMultipleShift = 6, + LoopControlPeelCountShift = 7, + LoopControlPartialCountShift = 8, + LoopControlMax = 0x7fffffff, +}; + +enum LoopControlMask { + LoopControlMaskNone = 0, + LoopControlUnrollMask = 0x00000001, + LoopControlDontUnrollMask = 0x00000002, + LoopControlDependencyInfiniteMask = 0x00000004, + LoopControlDependencyLengthMask = 0x00000008, + LoopControlMinIterationsMask = 0x00000010, + LoopControlMaxIterationsMask = 0x00000020, + LoopControlIterationMultipleMask = 0x00000040, + LoopControlPeelCountMask = 0x00000080, + LoopControlPartialCountMask = 0x00000100, +}; + +enum FunctionControlShift { + FunctionControlInlineShift = 0, + FunctionControlDontInlineShift = 1, + FunctionControlPureShift = 2, + FunctionControlConstShift = 3, + FunctionControlMax = 0x7fffffff, +}; + +enum FunctionControlMask { + FunctionControlMaskNone = 0, + FunctionControlInlineMask = 0x00000001, + FunctionControlDontInlineMask = 0x00000002, + FunctionControlPureMask = 0x00000004, + FunctionControlConstMask = 0x00000008, +}; + +enum MemorySemanticsShift { + MemorySemanticsAcquireShift = 1, + MemorySemanticsReleaseShift = 2, + MemorySemanticsAcquireReleaseShift = 3, + MemorySemanticsSequentiallyConsistentShift = 4, + MemorySemanticsUniformMemoryShift = 6, + MemorySemanticsSubgroupMemoryShift = 7, + MemorySemanticsWorkgroupMemoryShift = 8, + MemorySemanticsCrossWorkgroupMemoryShift = 9, + MemorySemanticsAtomicCounterMemoryShift = 10, + MemorySemanticsImageMemoryShift = 11, + MemorySemanticsOutputMemoryShift = 12, + MemorySemanticsOutputMemoryKHRShift = 12, + MemorySemanticsMakeAvailableShift = 13, + MemorySemanticsMakeAvailableKHRShift = 13, + MemorySemanticsMakeVisibleShift = 14, + MemorySemanticsMakeVisibleKHRShift = 14, + MemorySemanticsVolatileShift = 15, + MemorySemanticsMax = 0x7fffffff, +}; + +enum MemorySemanticsMask { + MemorySemanticsMaskNone = 0, + MemorySemanticsAcquireMask = 0x00000002, + MemorySemanticsReleaseMask = 0x00000004, + MemorySemanticsAcquireReleaseMask = 0x00000008, + MemorySemanticsSequentiallyConsistentMask = 0x00000010, + MemorySemanticsUniformMemoryMask = 0x00000040, + MemorySemanticsSubgroupMemoryMask = 0x00000080, + MemorySemanticsWorkgroupMemoryMask = 0x00000100, + MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200, + MemorySemanticsAtomicCounterMemoryMask = 0x00000400, + MemorySemanticsImageMemoryMask = 0x00000800, + MemorySemanticsOutputMemoryMask = 0x00001000, + MemorySemanticsOutputMemoryKHRMask = 0x00001000, + MemorySemanticsMakeAvailableMask = 0x00002000, + MemorySemanticsMakeAvailableKHRMask = 0x00002000, + MemorySemanticsMakeVisibleMask = 0x00004000, + MemorySemanticsMakeVisibleKHRMask = 0x00004000, + MemorySemanticsVolatileMask = 0x00008000, +}; + +enum MemoryAccessShift { + MemoryAccessVolatileShift = 0, + MemoryAccessAlignedShift = 1, + MemoryAccessNontemporalShift = 2, + MemoryAccessMakePointerAvailableShift = 3, + MemoryAccessMakePointerAvailableKHRShift = 3, + MemoryAccessMakePointerVisibleShift = 4, + MemoryAccessMakePointerVisibleKHRShift = 4, + MemoryAccessNonPrivatePointerShift = 5, + MemoryAccessNonPrivatePointerKHRShift = 5, + MemoryAccessMax = 0x7fffffff, +}; + +enum MemoryAccessMask { + MemoryAccessMaskNone = 0, + MemoryAccessVolatileMask = 0x00000001, + MemoryAccessAlignedMask = 0x00000002, + MemoryAccessNontemporalMask = 0x00000004, + MemoryAccessMakePointerAvailableMask = 0x00000008, + MemoryAccessMakePointerAvailableKHRMask = 0x00000008, + MemoryAccessMakePointerVisibleMask = 0x00000010, + MemoryAccessMakePointerVisibleKHRMask = 0x00000010, + MemoryAccessNonPrivatePointerMask = 0x00000020, + MemoryAccessNonPrivatePointerKHRMask = 0x00000020, +}; + +enum Scope { + ScopeCrossDevice = 0, + ScopeDevice = 1, + ScopeWorkgroup = 2, + ScopeSubgroup = 3, + ScopeInvocation = 4, + ScopeQueueFamily = 5, + ScopeQueueFamilyKHR = 5, + ScopeShaderCallKHR = 6, + ScopeMax = 0x7fffffff, +}; + +enum GroupOperation { + GroupOperationReduce = 0, + GroupOperationInclusiveScan = 1, + GroupOperationExclusiveScan = 2, + GroupOperationClusteredReduce = 3, + GroupOperationPartitionedReduceNV = 6, + GroupOperationPartitionedInclusiveScanNV = 7, + GroupOperationPartitionedExclusiveScanNV = 8, + GroupOperationMax = 0x7fffffff, +}; + +enum KernelEnqueueFlags { + KernelEnqueueFlagsNoWait = 0, + KernelEnqueueFlagsWaitKernel = 1, + KernelEnqueueFlagsWaitWorkGroup = 2, + KernelEnqueueFlagsMax = 0x7fffffff, +}; + +enum KernelProfilingInfoShift { + KernelProfilingInfoCmdExecTimeShift = 0, + KernelProfilingInfoMax = 0x7fffffff, +}; + +enum KernelProfilingInfoMask { + KernelProfilingInfoMaskNone = 0, + KernelProfilingInfoCmdExecTimeMask = 0x00000001, +}; + +enum Capability { + CapabilityMatrix = 0, + CapabilityShader = 1, + CapabilityGeometry = 2, + CapabilityTessellation = 3, + CapabilityAddresses = 4, + CapabilityLinkage = 5, + CapabilityKernel = 6, + CapabilityVector16 = 7, + CapabilityFloat16Buffer = 8, + CapabilityFloat16 = 9, + CapabilityFloat64 = 10, + CapabilityInt64 = 11, + CapabilityInt64Atomics = 12, + CapabilityImageBasic = 13, + CapabilityImageReadWrite = 14, + CapabilityImageMipmap = 15, + CapabilityPipes = 17, + CapabilityGroups = 18, + CapabilityDeviceEnqueue = 19, + CapabilityLiteralSampler = 20, + CapabilityAtomicStorage = 21, + CapabilityInt16 = 22, + CapabilityTessellationPointSize = 23, + CapabilityGeometryPointSize = 24, + CapabilityImageGatherExtended = 25, + CapabilityStorageImageMultisample = 27, + CapabilityUniformBufferArrayDynamicIndexing = 28, + CapabilitySampledImageArrayDynamicIndexing = 29, + CapabilityStorageBufferArrayDynamicIndexing = 30, + CapabilityStorageImageArrayDynamicIndexing = 31, + CapabilityClipDistance = 32, + CapabilityCullDistance = 33, + CapabilityImageCubeArray = 34, + CapabilitySampleRateShading = 35, + CapabilityImageRect = 36, + CapabilitySampledRect = 37, + CapabilityGenericPointer = 38, + CapabilityInt8 = 39, + CapabilityInputAttachment = 40, + CapabilitySparseResidency = 41, + CapabilityMinLod = 42, + CapabilitySampled1D = 43, + CapabilityImage1D = 44, + CapabilitySampledCubeArray = 45, + CapabilitySampledBuffer = 46, + CapabilityImageBuffer = 47, + CapabilityImageMSArray = 48, + CapabilityStorageImageExtendedFormats = 49, + CapabilityImageQuery = 50, + CapabilityDerivativeControl = 51, + CapabilityInterpolationFunction = 52, + CapabilityTransformFeedback = 53, + CapabilityGeometryStreams = 54, + CapabilityStorageImageReadWithoutFormat = 55, + CapabilityStorageImageWriteWithoutFormat = 56, + CapabilityMultiViewport = 57, + CapabilitySubgroupDispatch = 58, + CapabilityNamedBarrier = 59, + CapabilityPipeStorage = 60, + CapabilityGroupNonUniform = 61, + CapabilityGroupNonUniformVote = 62, + CapabilityGroupNonUniformArithmetic = 63, + CapabilityGroupNonUniformBallot = 64, + CapabilityGroupNonUniformShuffle = 65, + CapabilityGroupNonUniformShuffleRelative = 66, + CapabilityGroupNonUniformClustered = 67, + CapabilityGroupNonUniformQuad = 68, + CapabilityShaderLayer = 69, + CapabilityShaderViewportIndex = 70, + CapabilitySubgroupBallotKHR = 4423, + CapabilityDrawParameters = 4427, + CapabilitySubgroupVoteKHR = 4431, + CapabilityStorageBuffer16BitAccess = 4433, + CapabilityStorageUniformBufferBlock16 = 4433, + CapabilityStorageUniform16 = 4434, + CapabilityUniformAndStorageBuffer16BitAccess = 4434, + CapabilityStoragePushConstant16 = 4435, + CapabilityStorageInputOutput16 = 4436, + CapabilityDeviceGroup = 4437, + CapabilityMultiView = 4439, + CapabilityVariablePointersStorageBuffer = 4441, + CapabilityVariablePointers = 4442, + CapabilityAtomicStorageOps = 4445, + CapabilitySampleMaskPostDepthCoverage = 4447, + CapabilityStorageBuffer8BitAccess = 4448, + CapabilityUniformAndStorageBuffer8BitAccess = 4449, + CapabilityStoragePushConstant8 = 4450, + CapabilityDenormPreserve = 4464, + CapabilityDenormFlushToZero = 4465, + CapabilitySignedZeroInfNanPreserve = 4466, + CapabilityRoundingModeRTE = 4467, + CapabilityRoundingModeRTZ = 4468, + CapabilityRayQueryProvisionalKHR = 4471, + CapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478, + CapabilityFloat16ImageAMD = 5008, + CapabilityImageGatherBiasLodAMD = 5009, + CapabilityFragmentMaskAMD = 5010, + CapabilityStencilExportEXT = 5013, + CapabilityImageReadWriteLodAMD = 5015, + CapabilityShaderClockKHR = 5055, + CapabilitySampleMaskOverrideCoverageNV = 5249, + CapabilityGeometryShaderPassthroughNV = 5251, + CapabilityShaderViewportIndexLayerEXT = 5254, + CapabilityShaderViewportIndexLayerNV = 5254, + CapabilityShaderViewportMaskNV = 5255, + CapabilityShaderStereoViewNV = 5259, + CapabilityPerViewAttributesNV = 5260, + CapabilityFragmentFullyCoveredEXT = 5265, + CapabilityMeshShadingNV = 5266, + CapabilityImageFootprintNV = 5282, + CapabilityFragmentBarycentricNV = 5284, + CapabilityComputeDerivativeGroupQuadsNV = 5288, + CapabilityFragmentDensityEXT = 5291, + CapabilityShadingRateNV = 5291, + CapabilityGroupNonUniformPartitionedNV = 5297, + CapabilityShaderNonUniform = 5301, + CapabilityShaderNonUniformEXT = 5301, + CapabilityRuntimeDescriptorArray = 5302, + CapabilityRuntimeDescriptorArrayEXT = 5302, + CapabilityInputAttachmentArrayDynamicIndexing = 5303, + CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303, + CapabilityUniformTexelBufferArrayDynamicIndexing = 5304, + CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304, + CapabilityStorageTexelBufferArrayDynamicIndexing = 5305, + CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305, + CapabilityUniformBufferArrayNonUniformIndexing = 5306, + CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306, + CapabilitySampledImageArrayNonUniformIndexing = 5307, + CapabilitySampledImageArrayNonUniformIndexingEXT = 5307, + CapabilityStorageBufferArrayNonUniformIndexing = 5308, + CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308, + CapabilityStorageImageArrayNonUniformIndexing = 5309, + CapabilityStorageImageArrayNonUniformIndexingEXT = 5309, + CapabilityInputAttachmentArrayNonUniformIndexing = 5310, + CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310, + CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311, + CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311, + CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312, + CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312, + CapabilityRayTracingNV = 5340, + CapabilityVulkanMemoryModel = 5345, + CapabilityVulkanMemoryModelKHR = 5345, + CapabilityVulkanMemoryModelDeviceScope = 5346, + CapabilityVulkanMemoryModelDeviceScopeKHR = 5346, + CapabilityPhysicalStorageBufferAddresses = 5347, + CapabilityPhysicalStorageBufferAddressesEXT = 5347, + CapabilityComputeDerivativeGroupLinearNV = 5350, + CapabilityRayTracingProvisionalKHR = 5353, + CapabilityCooperativeMatrixNV = 5357, + CapabilityFragmentShaderSampleInterlockEXT = 5363, + CapabilityFragmentShaderShadingRateInterlockEXT = 5372, + CapabilityShaderSMBuiltinsNV = 5373, + CapabilityFragmentShaderPixelInterlockEXT = 5378, + CapabilityDemoteToHelperInvocationEXT = 5379, + CapabilitySubgroupShuffleINTEL = 5568, + CapabilitySubgroupBufferBlockIOINTEL = 5569, + CapabilitySubgroupImageBlockIOINTEL = 5570, + CapabilitySubgroupImageMediaBlockIOINTEL = 5579, + CapabilityIntegerFunctions2INTEL = 5584, + CapabilitySubgroupAvcMotionEstimationINTEL = 5696, + CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697, + CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698, + CapabilityMax = 0x7fffffff, +}; + +enum RayFlagsShift { + RayFlagsOpaqueKHRShift = 0, + RayFlagsNoOpaqueKHRShift = 1, + RayFlagsTerminateOnFirstHitKHRShift = 2, + RayFlagsSkipClosestHitShaderKHRShift = 3, + RayFlagsCullBackFacingTrianglesKHRShift = 4, + RayFlagsCullFrontFacingTrianglesKHRShift = 5, + RayFlagsCullOpaqueKHRShift = 6, + RayFlagsCullNoOpaqueKHRShift = 7, + RayFlagsSkipTrianglesKHRShift = 8, + RayFlagsSkipAABBsKHRShift = 9, + RayFlagsMax = 0x7fffffff, +}; + +enum RayFlagsMask { + RayFlagsMaskNone = 0, + RayFlagsOpaqueKHRMask = 0x00000001, + RayFlagsNoOpaqueKHRMask = 0x00000002, + RayFlagsTerminateOnFirstHitKHRMask = 0x00000004, + RayFlagsSkipClosestHitShaderKHRMask = 0x00000008, + RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010, + RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020, + RayFlagsCullOpaqueKHRMask = 0x00000040, + RayFlagsCullNoOpaqueKHRMask = 0x00000080, + RayFlagsSkipTrianglesKHRMask = 0x00000100, + RayFlagsSkipAABBsKHRMask = 0x00000200, +}; + +enum RayQueryIntersection { + RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0, + RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1, + RayQueryIntersectionMax = 0x7fffffff, +}; + +enum RayQueryCommittedIntersectionType { + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0, + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1, + RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2, + RayQueryCommittedIntersectionTypeMax = 0x7fffffff, +}; + +enum RayQueryCandidateIntersectionType { + RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0, + RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1, + RayQueryCandidateIntersectionTypeMax = 0x7fffffff, +}; + +enum Op { + OpNop = 0, + OpUndef = 1, + OpSourceContinued = 2, + OpSource = 3, + OpSourceExtension = 4, + OpName = 5, + OpMemberName = 6, + OpString = 7, + OpLine = 8, + OpExtension = 10, + OpExtInstImport = 11, + OpExtInst = 12, + OpMemoryModel = 14, + OpEntryPoint = 15, + OpExecutionMode = 16, + OpCapability = 17, + OpTypeVoid = 19, + OpTypeBool = 20, + OpTypeInt = 21, + OpTypeFloat = 22, + OpTypeVector = 23, + OpTypeMatrix = 24, + OpTypeImage = 25, + OpTypeSampler = 26, + OpTypeSampledImage = 27, + OpTypeArray = 28, + OpTypeRuntimeArray = 29, + OpTypeStruct = 30, + OpTypeOpaque = 31, + OpTypePointer = 32, + OpTypeFunction = 33, + OpTypeEvent = 34, + OpTypeDeviceEvent = 35, + OpTypeReserveId = 36, + OpTypeQueue = 37, + OpTypePipe = 38, + OpTypeForwardPointer = 39, + OpConstantTrue = 41, + OpConstantFalse = 42, + OpConstant = 43, + OpConstantComposite = 44, + OpConstantSampler = 45, + OpConstantNull = 46, + OpSpecConstantTrue = 48, + OpSpecConstantFalse = 49, + OpSpecConstant = 50, + OpSpecConstantComposite = 51, + OpSpecConstantOp = 52, + OpFunction = 54, + OpFunctionParameter = 55, + OpFunctionEnd = 56, + OpFunctionCall = 57, + OpVariable = 59, + OpImageTexelPointer = 60, + OpLoad = 61, + OpStore = 62, + OpCopyMemory = 63, + OpCopyMemorySized = 64, + OpAccessChain = 65, + OpInBoundsAccessChain = 66, + OpPtrAccessChain = 67, + OpArrayLength = 68, + OpGenericPtrMemSemantics = 69, + OpInBoundsPtrAccessChain = 70, + OpDecorate = 71, + OpMemberDecorate = 72, + OpDecorationGroup = 73, + OpGroupDecorate = 74, + OpGroupMemberDecorate = 75, + OpVectorExtractDynamic = 77, + OpVectorInsertDynamic = 78, + OpVectorShuffle = 79, + OpCompositeConstruct = 80, + OpCompositeExtract = 81, + OpCompositeInsert = 82, + OpCopyObject = 83, + OpTranspose = 84, + OpSampledImage = 86, + OpImageSampleImplicitLod = 87, + OpImageSampleExplicitLod = 88, + OpImageSampleDrefImplicitLod = 89, + OpImageSampleDrefExplicitLod = 90, + OpImageSampleProjImplicitLod = 91, + OpImageSampleProjExplicitLod = 92, + OpImageSampleProjDrefImplicitLod = 93, + OpImageSampleProjDrefExplicitLod = 94, + OpImageFetch = 95, + OpImageGather = 96, + OpImageDrefGather = 97, + OpImageRead = 98, + OpImageWrite = 99, + OpImage = 100, + OpImageQueryFormat = 101, + OpImageQueryOrder = 102, + OpImageQuerySizeLod = 103, + OpImageQuerySize = 104, + OpImageQueryLod = 105, + OpImageQueryLevels = 106, + OpImageQuerySamples = 107, + OpConvertFToU = 109, + OpConvertFToS = 110, + OpConvertSToF = 111, + OpConvertUToF = 112, + OpUConvert = 113, + OpSConvert = 114, + OpFConvert = 115, + OpQuantizeToF16 = 116, + OpConvertPtrToU = 117, + OpSatConvertSToU = 118, + OpSatConvertUToS = 119, + OpConvertUToPtr = 120, + OpPtrCastToGeneric = 121, + OpGenericCastToPtr = 122, + OpGenericCastToPtrExplicit = 123, + OpBitcast = 124, + OpSNegate = 126, + OpFNegate = 127, + OpIAdd = 128, + OpFAdd = 129, + OpISub = 130, + OpFSub = 131, + OpIMul = 132, + OpFMul = 133, + OpUDiv = 134, + OpSDiv = 135, + OpFDiv = 136, + OpUMod = 137, + OpSRem = 138, + OpSMod = 139, + OpFRem = 140, + OpFMod = 141, + OpVectorTimesScalar = 142, + OpMatrixTimesScalar = 143, + OpVectorTimesMatrix = 144, + OpMatrixTimesVector = 145, + OpMatrixTimesMatrix = 146, + OpOuterProduct = 147, + OpDot = 148, + OpIAddCarry = 149, + OpISubBorrow = 150, + OpUMulExtended = 151, + OpSMulExtended = 152, + OpAny = 154, + OpAll = 155, + OpIsNan = 156, + OpIsInf = 157, + OpIsFinite = 158, + OpIsNormal = 159, + OpSignBitSet = 160, + OpLessOrGreater = 161, + OpOrdered = 162, + OpUnordered = 163, + OpLogicalEqual = 164, + OpLogicalNotEqual = 165, + OpLogicalOr = 166, + OpLogicalAnd = 167, + OpLogicalNot = 168, + OpSelect = 169, + OpIEqual = 170, + OpINotEqual = 171, + OpUGreaterThan = 172, + OpSGreaterThan = 173, + OpUGreaterThanEqual = 174, + OpSGreaterThanEqual = 175, + OpULessThan = 176, + OpSLessThan = 177, + OpULessThanEqual = 178, + OpSLessThanEqual = 179, + OpFOrdEqual = 180, + OpFUnordEqual = 181, + OpFOrdNotEqual = 182, + OpFUnordNotEqual = 183, + OpFOrdLessThan = 184, + OpFUnordLessThan = 185, + OpFOrdGreaterThan = 186, + OpFUnordGreaterThan = 187, + OpFOrdLessThanEqual = 188, + OpFUnordLessThanEqual = 189, + OpFOrdGreaterThanEqual = 190, + OpFUnordGreaterThanEqual = 191, + OpShiftRightLogical = 194, + OpShiftRightArithmetic = 195, + OpShiftLeftLogical = 196, + OpBitwiseOr = 197, + OpBitwiseXor = 198, + OpBitwiseAnd = 199, + OpNot = 200, + OpBitFieldInsert = 201, + OpBitFieldSExtract = 202, + OpBitFieldUExtract = 203, + OpBitReverse = 204, + OpBitCount = 205, + OpDPdx = 207, + OpDPdy = 208, + OpFwidth = 209, + OpDPdxFine = 210, + OpDPdyFine = 211, + OpFwidthFine = 212, + OpDPdxCoarse = 213, + OpDPdyCoarse = 214, + OpFwidthCoarse = 215, + OpEmitVertex = 218, + OpEndPrimitive = 219, + OpEmitStreamVertex = 220, + OpEndStreamPrimitive = 221, + OpControlBarrier = 224, + OpMemoryBarrier = 225, + OpAtomicLoad = 227, + OpAtomicStore = 228, + OpAtomicExchange = 229, + OpAtomicCompareExchange = 230, + OpAtomicCompareExchangeWeak = 231, + OpAtomicIIncrement = 232, + OpAtomicIDecrement = 233, + OpAtomicIAdd = 234, + OpAtomicISub = 235, + OpAtomicSMin = 236, + OpAtomicUMin = 237, + OpAtomicSMax = 238, + OpAtomicUMax = 239, + OpAtomicAnd = 240, + OpAtomicOr = 241, + OpAtomicXor = 242, + OpPhi = 245, + OpLoopMerge = 246, + OpSelectionMerge = 247, + OpLabel = 248, + OpBranch = 249, + OpBranchConditional = 250, + OpSwitch = 251, + OpKill = 252, + OpReturn = 253, + OpReturnValue = 254, + OpUnreachable = 255, + OpLifetimeStart = 256, + OpLifetimeStop = 257, + OpGroupAsyncCopy = 259, + OpGroupWaitEvents = 260, + OpGroupAll = 261, + OpGroupAny = 262, + OpGroupBroadcast = 263, + OpGroupIAdd = 264, + OpGroupFAdd = 265, + OpGroupFMin = 266, + OpGroupUMin = 267, + OpGroupSMin = 268, + OpGroupFMax = 269, + OpGroupUMax = 270, + OpGroupSMax = 271, + OpReadPipe = 274, + OpWritePipe = 275, + OpReservedReadPipe = 276, + OpReservedWritePipe = 277, + OpReserveReadPipePackets = 278, + OpReserveWritePipePackets = 279, + OpCommitReadPipe = 280, + OpCommitWritePipe = 281, + OpIsValidReserveId = 282, + OpGetNumPipePackets = 283, + OpGetMaxPipePackets = 284, + OpGroupReserveReadPipePackets = 285, + OpGroupReserveWritePipePackets = 286, + OpGroupCommitReadPipe = 287, + OpGroupCommitWritePipe = 288, + OpEnqueueMarker = 291, + OpEnqueueKernel = 292, + OpGetKernelNDrangeSubGroupCount = 293, + OpGetKernelNDrangeMaxSubGroupSize = 294, + OpGetKernelWorkGroupSize = 295, + OpGetKernelPreferredWorkGroupSizeMultiple = 296, + OpRetainEvent = 297, + OpReleaseEvent = 298, + OpCreateUserEvent = 299, + OpIsValidEvent = 300, + OpSetUserEventStatus = 301, + OpCaptureEventProfilingInfo = 302, + OpGetDefaultQueue = 303, + OpBuildNDRange = 304, + OpImageSparseSampleImplicitLod = 305, + OpImageSparseSampleExplicitLod = 306, + OpImageSparseSampleDrefImplicitLod = 307, + OpImageSparseSampleDrefExplicitLod = 308, + OpImageSparseSampleProjImplicitLod = 309, + OpImageSparseSampleProjExplicitLod = 310, + OpImageSparseSampleProjDrefImplicitLod = 311, + OpImageSparseSampleProjDrefExplicitLod = 312, + OpImageSparseFetch = 313, + OpImageSparseGather = 314, + OpImageSparseDrefGather = 315, + OpImageSparseTexelsResident = 316, + OpNoLine = 317, + OpAtomicFlagTestAndSet = 318, + OpAtomicFlagClear = 319, + OpImageSparseRead = 320, + OpSizeOf = 321, + OpTypePipeStorage = 322, + OpConstantPipeStorage = 323, + OpCreatePipeFromPipeStorage = 324, + OpGetKernelLocalSizeForSubgroupCount = 325, + OpGetKernelMaxNumSubgroups = 326, + OpTypeNamedBarrier = 327, + OpNamedBarrierInitialize = 328, + OpMemoryNamedBarrier = 329, + OpModuleProcessed = 330, + OpExecutionModeId = 331, + OpDecorateId = 332, + OpGroupNonUniformElect = 333, + OpGroupNonUniformAll = 334, + OpGroupNonUniformAny = 335, + OpGroupNonUniformAllEqual = 336, + OpGroupNonUniformBroadcast = 337, + OpGroupNonUniformBroadcastFirst = 338, + OpGroupNonUniformBallot = 339, + OpGroupNonUniformInverseBallot = 340, + OpGroupNonUniformBallotBitExtract = 341, + OpGroupNonUniformBallotBitCount = 342, + OpGroupNonUniformBallotFindLSB = 343, + OpGroupNonUniformBallotFindMSB = 344, + OpGroupNonUniformShuffle = 345, + OpGroupNonUniformShuffleXor = 346, + OpGroupNonUniformShuffleUp = 347, + OpGroupNonUniformShuffleDown = 348, + OpGroupNonUniformIAdd = 349, + OpGroupNonUniformFAdd = 350, + OpGroupNonUniformIMul = 351, + OpGroupNonUniformFMul = 352, + OpGroupNonUniformSMin = 353, + OpGroupNonUniformUMin = 354, + OpGroupNonUniformFMin = 355, + OpGroupNonUniformSMax = 356, + OpGroupNonUniformUMax = 357, + OpGroupNonUniformFMax = 358, + OpGroupNonUniformBitwiseAnd = 359, + OpGroupNonUniformBitwiseOr = 360, + OpGroupNonUniformBitwiseXor = 361, + OpGroupNonUniformLogicalAnd = 362, + OpGroupNonUniformLogicalOr = 363, + OpGroupNonUniformLogicalXor = 364, + OpGroupNonUniformQuadBroadcast = 365, + OpGroupNonUniformQuadSwap = 366, + OpCopyLogical = 400, + OpPtrEqual = 401, + OpPtrNotEqual = 402, + OpPtrDiff = 403, + OpSubgroupBallotKHR = 4421, + OpSubgroupFirstInvocationKHR = 4422, + OpSubgroupAllKHR = 4428, + OpSubgroupAnyKHR = 4429, + OpSubgroupAllEqualKHR = 4430, + OpSubgroupReadInvocationKHR = 4432, + OpTypeRayQueryProvisionalKHR = 4472, + OpRayQueryInitializeKHR = 4473, + OpRayQueryTerminateKHR = 4474, + OpRayQueryGenerateIntersectionKHR = 4475, + OpRayQueryConfirmIntersectionKHR = 4476, + OpRayQueryProceedKHR = 4477, + OpRayQueryGetIntersectionTypeKHR = 4479, + OpGroupIAddNonUniformAMD = 5000, + OpGroupFAddNonUniformAMD = 5001, + OpGroupFMinNonUniformAMD = 5002, + OpGroupUMinNonUniformAMD = 5003, + OpGroupSMinNonUniformAMD = 5004, + OpGroupFMaxNonUniformAMD = 5005, + OpGroupUMaxNonUniformAMD = 5006, + OpGroupSMaxNonUniformAMD = 5007, + OpFragmentMaskFetchAMD = 5011, + OpFragmentFetchAMD = 5012, + OpReadClockKHR = 5056, + OpImageSampleFootprintNV = 5283, + OpGroupNonUniformPartitionNV = 5296, + OpWritePackedPrimitiveIndices4x8NV = 5299, + OpReportIntersectionKHR = 5334, + OpReportIntersectionNV = 5334, + OpIgnoreIntersectionKHR = 5335, + OpIgnoreIntersectionNV = 5335, + OpTerminateRayKHR = 5336, + OpTerminateRayNV = 5336, + OpTraceNV = 5337, + OpTraceRayKHR = 5337, + OpTypeAccelerationStructureKHR = 5341, + OpTypeAccelerationStructureNV = 5341, + OpExecuteCallableKHR = 5344, + OpExecuteCallableNV = 5344, + OpTypeCooperativeMatrixNV = 5358, + OpCooperativeMatrixLoadNV = 5359, + OpCooperativeMatrixStoreNV = 5360, + OpCooperativeMatrixMulAddNV = 5361, + OpCooperativeMatrixLengthNV = 5362, + OpBeginInvocationInterlockEXT = 5364, + OpEndInvocationInterlockEXT = 5365, + OpDemoteToHelperInvocationEXT = 5380, + OpIsHelperInvocationEXT = 5381, + OpSubgroupShuffleINTEL = 5571, + OpSubgroupShuffleDownINTEL = 5572, + OpSubgroupShuffleUpINTEL = 5573, + OpSubgroupShuffleXorINTEL = 5574, + OpSubgroupBlockReadINTEL = 5575, + OpSubgroupBlockWriteINTEL = 5576, + OpSubgroupImageBlockReadINTEL = 5577, + OpSubgroupImageBlockWriteINTEL = 5578, + OpSubgroupImageMediaBlockReadINTEL = 5580, + OpSubgroupImageMediaBlockWriteINTEL = 5581, + OpUCountLeadingZerosINTEL = 5585, + OpUCountTrailingZerosINTEL = 5586, + OpAbsISubINTEL = 5587, + OpAbsUSubINTEL = 5588, + OpIAddSatINTEL = 5589, + OpUAddSatINTEL = 5590, + OpIAverageINTEL = 5591, + OpUAverageINTEL = 5592, + OpIAverageRoundedINTEL = 5593, + OpUAverageRoundedINTEL = 5594, + OpISubSatINTEL = 5595, + OpUSubSatINTEL = 5596, + OpIMul32x16INTEL = 5597, + OpUMul32x16INTEL = 5598, + OpDecorateString = 5632, + OpDecorateStringGOOGLE = 5632, + OpMemberDecorateString = 5633, + OpMemberDecorateStringGOOGLE = 5633, + OpVmeImageINTEL = 5699, + OpTypeVmeImageINTEL = 5700, + OpTypeAvcImePayloadINTEL = 5701, + OpTypeAvcRefPayloadINTEL = 5702, + OpTypeAvcSicPayloadINTEL = 5703, + OpTypeAvcMcePayloadINTEL = 5704, + OpTypeAvcMceResultINTEL = 5705, + OpTypeAvcImeResultINTEL = 5706, + OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707, + OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708, + OpTypeAvcImeSingleReferenceStreaminINTEL = 5709, + OpTypeAvcImeDualReferenceStreaminINTEL = 5710, + OpTypeAvcRefResultINTEL = 5711, + OpTypeAvcSicResultINTEL = 5712, + OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713, + OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714, + OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715, + OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716, + OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717, + OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718, + OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719, + OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720, + OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721, + OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722, + OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723, + OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724, + OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725, + OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726, + OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727, + OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728, + OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729, + OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730, + OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731, + OpSubgroupAvcMceConvertToImePayloadINTEL = 5732, + OpSubgroupAvcMceConvertToImeResultINTEL = 5733, + OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734, + OpSubgroupAvcMceConvertToRefResultINTEL = 5735, + OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736, + OpSubgroupAvcMceConvertToSicResultINTEL = 5737, + OpSubgroupAvcMceGetMotionVectorsINTEL = 5738, + OpSubgroupAvcMceGetInterDistortionsINTEL = 5739, + OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740, + OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741, + OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742, + OpSubgroupAvcMceGetInterDirectionsINTEL = 5743, + OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744, + OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745, + OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746, + OpSubgroupAvcImeInitializeINTEL = 5747, + OpSubgroupAvcImeSetSingleReferenceINTEL = 5748, + OpSubgroupAvcImeSetDualReferenceINTEL = 5749, + OpSubgroupAvcImeRefWindowSizeINTEL = 5750, + OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751, + OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752, + OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753, + OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754, + OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755, + OpSubgroupAvcImeSetWeightedSadINTEL = 5756, + OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757, + OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759, + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761, + OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762, + OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763, + OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764, + OpSubgroupAvcImeConvertToMceResultINTEL = 5765, + OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766, + OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767, + OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768, + OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771, + OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774, + OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775, + OpSubgroupAvcImeGetBorderReachedINTEL = 5776, + OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777, + OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778, + OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779, + OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780, + OpSubgroupAvcFmeInitializeINTEL = 5781, + OpSubgroupAvcBmeInitializeINTEL = 5782, + OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783, + OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784, + OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785, + OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786, + OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787, + OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788, + OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789, + OpSubgroupAvcRefConvertToMceResultINTEL = 5790, + OpSubgroupAvcSicInitializeINTEL = 5791, + OpSubgroupAvcSicConfigureSkcINTEL = 5792, + OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793, + OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794, + OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795, + OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796, + OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797, + OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798, + OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799, + OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800, + OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801, + OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802, + OpSubgroupAvcSicEvaluateIpeINTEL = 5803, + OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804, + OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805, + OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806, + OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807, + OpSubgroupAvcSicConvertToMceResultINTEL = 5808, + OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809, + OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810, + OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811, + OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812, + OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813, + OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814, + OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815, + OpSubgroupAvcSicGetInterRawSadsINTEL = 5816, + OpRayQueryGetRayTMinKHR = 6016, + OpRayQueryGetRayFlagsKHR = 6017, + OpRayQueryGetIntersectionTKHR = 6018, + OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019, + OpRayQueryGetIntersectionInstanceIdKHR = 6020, + OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021, + OpRayQueryGetIntersectionGeometryIndexKHR = 6022, + OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023, + OpRayQueryGetIntersectionBarycentricsKHR = 6024, + OpRayQueryGetIntersectionFrontFaceKHR = 6025, + OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026, + OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027, + OpRayQueryGetIntersectionObjectRayOriginKHR = 6028, + OpRayQueryGetWorldRayDirectionKHR = 6029, + OpRayQueryGetWorldRayOriginKHR = 6030, + OpRayQueryGetIntersectionObjectToWorldKHR = 6031, + OpRayQueryGetIntersectionWorldToObjectKHR = 6032, + OpMax = 0x7fffffff, +}; + +#ifdef SPV_ENABLE_UTILITY_CODE +inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) { + *hasResult = *hasResultType = false; + switch (opcode) { + default: /* unknown opcode */ break; + case OpNop: *hasResult = false; *hasResultType = false; break; + case OpUndef: *hasResult = true; *hasResultType = true; break; + case OpSourceContinued: *hasResult = false; *hasResultType = false; break; + case OpSource: *hasResult = false; *hasResultType = false; break; + case OpSourceExtension: *hasResult = false; *hasResultType = false; break; + case OpName: *hasResult = false; *hasResultType = false; break; + case OpMemberName: *hasResult = false; *hasResultType = false; break; + case OpString: *hasResult = true; *hasResultType = false; break; + case OpLine: *hasResult = false; *hasResultType = false; break; + case OpExtension: *hasResult = false; *hasResultType = false; break; + case OpExtInstImport: *hasResult = true; *hasResultType = false; break; + case OpExtInst: *hasResult = true; *hasResultType = true; break; + case OpMemoryModel: *hasResult = false; *hasResultType = false; break; + case OpEntryPoint: *hasResult = false; *hasResultType = false; break; + case OpExecutionMode: *hasResult = false; *hasResultType = false; break; + case OpCapability: *hasResult = false; *hasResultType = false; break; + case OpTypeVoid: *hasResult = true; *hasResultType = false; break; + case OpTypeBool: *hasResult = true; *hasResultType = false; break; + case OpTypeInt: *hasResult = true; *hasResultType = false; break; + case OpTypeFloat: *hasResult = true; *hasResultType = false; break; + case OpTypeVector: *hasResult = true; *hasResultType = false; break; + case OpTypeMatrix: *hasResult = true; *hasResultType = false; break; + case OpTypeImage: *hasResult = true; *hasResultType = false; break; + case OpTypeSampler: *hasResult = true; *hasResultType = false; break; + case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break; + case OpTypeArray: *hasResult = true; *hasResultType = false; break; + case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break; + case OpTypeStruct: *hasResult = true; *hasResultType = false; break; + case OpTypeOpaque: *hasResult = true; *hasResultType = false; break; + case OpTypePointer: *hasResult = true; *hasResultType = false; break; + case OpTypeFunction: *hasResult = true; *hasResultType = false; break; + case OpTypeEvent: *hasResult = true; *hasResultType = false; break; + case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break; + case OpTypeReserveId: *hasResult = true; *hasResultType = false; break; + case OpTypeQueue: *hasResult = true; *hasResultType = false; break; + case OpTypePipe: *hasResult = true; *hasResultType = false; break; + case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break; + case OpConstantTrue: *hasResult = true; *hasResultType = true; break; + case OpConstantFalse: *hasResult = true; *hasResultType = true; break; + case OpConstant: *hasResult = true; *hasResultType = true; break; + case OpConstantComposite: *hasResult = true; *hasResultType = true; break; + case OpConstantSampler: *hasResult = true; *hasResultType = true; break; + case OpConstantNull: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break; + case OpSpecConstant: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break; + case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break; + case OpFunction: *hasResult = true; *hasResultType = true; break; + case OpFunctionParameter: *hasResult = true; *hasResultType = true; break; + case OpFunctionEnd: *hasResult = false; *hasResultType = false; break; + case OpFunctionCall: *hasResult = true; *hasResultType = true; break; + case OpVariable: *hasResult = true; *hasResultType = true; break; + case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break; + case OpLoad: *hasResult = true; *hasResultType = true; break; + case OpStore: *hasResult = false; *hasResultType = false; break; + case OpCopyMemory: *hasResult = false; *hasResultType = false; break; + case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break; + case OpAccessChain: *hasResult = true; *hasResultType = true; break; + case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break; + case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case OpArrayLength: *hasResult = true; *hasResultType = true; break; + case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break; + case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break; + case OpDecorate: *hasResult = false; *hasResultType = false; break; + case OpMemberDecorate: *hasResult = false; *hasResultType = false; break; + case OpDecorationGroup: *hasResult = true; *hasResultType = false; break; + case OpGroupDecorate: *hasResult = false; *hasResultType = false; break; + case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break; + case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break; + case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break; + case OpVectorShuffle: *hasResult = true; *hasResultType = true; break; + case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break; + case OpCompositeExtract: *hasResult = true; *hasResultType = true; break; + case OpCompositeInsert: *hasResult = true; *hasResultType = true; break; + case OpCopyObject: *hasResult = true; *hasResultType = true; break; + case OpTranspose: *hasResult = true; *hasResultType = true; break; + case OpSampledImage: *hasResult = true; *hasResultType = true; break; + case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageFetch: *hasResult = true; *hasResultType = true; break; + case OpImageGather: *hasResult = true; *hasResultType = true; break; + case OpImageDrefGather: *hasResult = true; *hasResultType = true; break; + case OpImageRead: *hasResult = true; *hasResultType = true; break; + case OpImageWrite: *hasResult = false; *hasResultType = false; break; + case OpImage: *hasResult = true; *hasResultType = true; break; + case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break; + case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySize: *hasResult = true; *hasResultType = true; break; + case OpImageQueryLod: *hasResult = true; *hasResultType = true; break; + case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break; + case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break; + case OpConvertFToU: *hasResult = true; *hasResultType = true; break; + case OpConvertFToS: *hasResult = true; *hasResultType = true; break; + case OpConvertSToF: *hasResult = true; *hasResultType = true; break; + case OpConvertUToF: *hasResult = true; *hasResultType = true; break; + case OpUConvert: *hasResult = true; *hasResultType = true; break; + case OpSConvert: *hasResult = true; *hasResultType = true; break; + case OpFConvert: *hasResult = true; *hasResultType = true; break; + case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break; + case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break; + case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break; + case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break; + case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break; + case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break; + case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break; + case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break; + case OpBitcast: *hasResult = true; *hasResultType = true; break; + case OpSNegate: *hasResult = true; *hasResultType = true; break; + case OpFNegate: *hasResult = true; *hasResultType = true; break; + case OpIAdd: *hasResult = true; *hasResultType = true; break; + case OpFAdd: *hasResult = true; *hasResultType = true; break; + case OpISub: *hasResult = true; *hasResultType = true; break; + case OpFSub: *hasResult = true; *hasResultType = true; break; + case OpIMul: *hasResult = true; *hasResultType = true; break; + case OpFMul: *hasResult = true; *hasResultType = true; break; + case OpUDiv: *hasResult = true; *hasResultType = true; break; + case OpSDiv: *hasResult = true; *hasResultType = true; break; + case OpFDiv: *hasResult = true; *hasResultType = true; break; + case OpUMod: *hasResult = true; *hasResultType = true; break; + case OpSRem: *hasResult = true; *hasResultType = true; break; + case OpSMod: *hasResult = true; *hasResultType = true; break; + case OpFRem: *hasResult = true; *hasResultType = true; break; + case OpFMod: *hasResult = true; *hasResultType = true; break; + case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break; + case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break; + case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break; + case OpOuterProduct: *hasResult = true; *hasResultType = true; break; + case OpDot: *hasResult = true; *hasResultType = true; break; + case OpIAddCarry: *hasResult = true; *hasResultType = true; break; + case OpISubBorrow: *hasResult = true; *hasResultType = true; break; + case OpUMulExtended: *hasResult = true; *hasResultType = true; break; + case OpSMulExtended: *hasResult = true; *hasResultType = true; break; + case OpAny: *hasResult = true; *hasResultType = true; break; + case OpAll: *hasResult = true; *hasResultType = true; break; + case OpIsNan: *hasResult = true; *hasResultType = true; break; + case OpIsInf: *hasResult = true; *hasResultType = true; break; + case OpIsFinite: *hasResult = true; *hasResultType = true; break; + case OpIsNormal: *hasResult = true; *hasResultType = true; break; + case OpSignBitSet: *hasResult = true; *hasResultType = true; break; + case OpLessOrGreater: *hasResult = true; *hasResultType = true; break; + case OpOrdered: *hasResult = true; *hasResultType = true; break; + case OpUnordered: *hasResult = true; *hasResultType = true; break; + case OpLogicalEqual: *hasResult = true; *hasResultType = true; break; + case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break; + case OpLogicalOr: *hasResult = true; *hasResultType = true; break; + case OpLogicalAnd: *hasResult = true; *hasResultType = true; break; + case OpLogicalNot: *hasResult = true; *hasResultType = true; break; + case OpSelect: *hasResult = true; *hasResultType = true; break; + case OpIEqual: *hasResult = true; *hasResultType = true; break; + case OpINotEqual: *hasResult = true; *hasResultType = true; break; + case OpUGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpSGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpULessThan: *hasResult = true; *hasResultType = true; break; + case OpSLessThan: *hasResult = true; *hasResultType = true; break; + case OpULessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break; + case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break; + case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break; + case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break; + case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break; + case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break; + case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break; + case OpBitwiseOr: *hasResult = true; *hasResultType = true; break; + case OpBitwiseXor: *hasResult = true; *hasResultType = true; break; + case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case OpNot: *hasResult = true; *hasResultType = true; break; + case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break; + case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break; + case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break; + case OpBitReverse: *hasResult = true; *hasResultType = true; break; + case OpBitCount: *hasResult = true; *hasResultType = true; break; + case OpDPdx: *hasResult = true; *hasResultType = true; break; + case OpDPdy: *hasResult = true; *hasResultType = true; break; + case OpFwidth: *hasResult = true; *hasResultType = true; break; + case OpDPdxFine: *hasResult = true; *hasResultType = true; break; + case OpDPdyFine: *hasResult = true; *hasResultType = true; break; + case OpFwidthFine: *hasResult = true; *hasResultType = true; break; + case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break; + case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break; + case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break; + case OpEmitVertex: *hasResult = false; *hasResultType = false; break; + case OpEndPrimitive: *hasResult = false; *hasResultType = false; break; + case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break; + case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break; + case OpControlBarrier: *hasResult = false; *hasResultType = false; break; + case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break; + case OpAtomicLoad: *hasResult = true; *hasResultType = true; break; + case OpAtomicStore: *hasResult = false; *hasResultType = false; break; + case OpAtomicExchange: *hasResult = true; *hasResultType = true; break; + case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break; + case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break; + case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break; + case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break; + case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break; + case OpAtomicISub: *hasResult = true; *hasResultType = true; break; + case OpAtomicSMin: *hasResult = true; *hasResultType = true; break; + case OpAtomicUMin: *hasResult = true; *hasResultType = true; break; + case OpAtomicSMax: *hasResult = true; *hasResultType = true; break; + case OpAtomicUMax: *hasResult = true; *hasResultType = true; break; + case OpAtomicAnd: *hasResult = true; *hasResultType = true; break; + case OpAtomicOr: *hasResult = true; *hasResultType = true; break; + case OpAtomicXor: *hasResult = true; *hasResultType = true; break; + case OpPhi: *hasResult = true; *hasResultType = true; break; + case OpLoopMerge: *hasResult = false; *hasResultType = false; break; + case OpSelectionMerge: *hasResult = false; *hasResultType = false; break; + case OpLabel: *hasResult = true; *hasResultType = false; break; + case OpBranch: *hasResult = false; *hasResultType = false; break; + case OpBranchConditional: *hasResult = false; *hasResultType = false; break; + case OpSwitch: *hasResult = false; *hasResultType = false; break; + case OpKill: *hasResult = false; *hasResultType = false; break; + case OpReturn: *hasResult = false; *hasResultType = false; break; + case OpReturnValue: *hasResult = false; *hasResultType = false; break; + case OpUnreachable: *hasResult = false; *hasResultType = false; break; + case OpLifetimeStart: *hasResult = false; *hasResultType = false; break; + case OpLifetimeStop: *hasResult = false; *hasResultType = false; break; + case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break; + case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break; + case OpGroupAll: *hasResult = true; *hasResultType = true; break; + case OpGroupAny: *hasResult = true; *hasResultType = true; break; + case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupIAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupFAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupFMin: *hasResult = true; *hasResultType = true; break; + case OpGroupUMin: *hasResult = true; *hasResultType = true; break; + case OpGroupSMin: *hasResult = true; *hasResultType = true; break; + case OpGroupFMax: *hasResult = true; *hasResultType = true; break; + case OpGroupUMax: *hasResult = true; *hasResultType = true; break; + case OpGroupSMax: *hasResult = true; *hasResultType = true; break; + case OpReadPipe: *hasResult = true; *hasResultType = true; break; + case OpWritePipe: *hasResult = true; *hasResultType = true; break; + case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break; + case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break; + case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break; + case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break; + case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break; + case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break; + case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break; + case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break; + case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break; + case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break; + case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break; + case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break; + case OpRetainEvent: *hasResult = false; *hasResultType = false; break; + case OpReleaseEvent: *hasResult = false; *hasResultType = false; break; + case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break; + case OpIsValidEvent: *hasResult = true; *hasResultType = true; break; + case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break; + case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break; + case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break; + case OpBuildNDRange: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break; + case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break; + case OpImageSparseGather: *hasResult = true; *hasResultType = true; break; + case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break; + case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break; + case OpNoLine: *hasResult = false; *hasResultType = false; break; + case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break; + case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break; + case OpImageSparseRead: *hasResult = true; *hasResultType = true; break; + case OpSizeOf: *hasResult = true; *hasResultType = true; break; + case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break; + case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break; + case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break; + case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break; + case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break; + case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break; + case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break; + case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break; + case OpModuleProcessed: *hasResult = false; *hasResultType = false; break; + case OpExecutionModeId: *hasResult = false; *hasResultType = false; break; + case OpDecorateId: *hasResult = false; *hasResultType = false; break; + case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break; + case OpCopyLogical: *hasResult = true; *hasResultType = true; break; + case OpPtrEqual: *hasResult = true; *hasResultType = true; break; + case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break; + case OpPtrDiff: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break; + case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break; + case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break; + case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break; + case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break; + case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break; + case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break; + case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break; + case OpReadClockKHR: *hasResult = true; *hasResultType = true; break; + case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break; + case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break; + case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break; + case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break; + case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break; + case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break; + case OpTraceNV: *hasResult = false; *hasResultType = false; break; + case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break; + case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break; + case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break; + case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break; + case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break; + case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break; + case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break; + case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break; + case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break; + case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break; + case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break; + case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break; + case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break; + case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break; + case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break; + case OpDecorateString: *hasResult = false; *hasResultType = false; break; + case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break; + case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break; + case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break; + case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break; + case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break; + case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break; + } +} +#endif /* SPV_ENABLE_UTILITY_CODE */ + +// Overload operator| for mask bit combining + +inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); } +inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); } +inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); } +inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); } +inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); } +inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); } +inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); } +inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); } +inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); } + +} // end namespace spv + +#endif // #ifndef spirv_HPP + diff --git a/android/x86_64/include/glslang/SPIRV/spvIR.h b/android/x86_64/include/glslang/SPIRV/spvIR.h new file mode 100755 index 00000000..6523035e --- /dev/null +++ b/android/x86_64/include/glslang/SPIRV/spvIR.h @@ -0,0 +1,485 @@ +// +// Copyright (C) 2014 LunarG, Inc. +// Copyright (C) 2015-2018 Google, Inc. +// +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions +// are met: +// +// Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// +// 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. +// +// Neither the name of 3Dlabs Inc. Ltd. 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 HOLDERS 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. + +// SPIRV-IR +// +// Simple in-memory representation (IR) of SPIRV. Just for holding +// Each function's CFG of blocks. Has this hierarchy: +// - Module, which is a list of +// - Function, which is a list of +// - Block, which is a list of +// - Instruction +// + +#pragma once +#ifndef spvIR_H +#define spvIR_H + +#include "spirv.hpp" + +#include +#include +#include +#include +#include +#include + +namespace spv { + +class Block; +class Function; +class Module; + +const Id NoResult = 0; +const Id NoType = 0; + +const Decoration NoPrecision = DecorationMax; + +#ifdef __GNUC__ +# define POTENTIALLY_UNUSED __attribute__((unused)) +#else +# define POTENTIALLY_UNUSED +#endif + +POTENTIALLY_UNUSED +const MemorySemanticsMask MemorySemanticsAllMemory = + (MemorySemanticsMask)(MemorySemanticsUniformMemoryMask | + MemorySemanticsWorkgroupMemoryMask | + MemorySemanticsAtomicCounterMemoryMask | + MemorySemanticsImageMemoryMask); + +struct IdImmediate { + bool isId; // true if word is an Id, false if word is an immediate + unsigned word; + IdImmediate(bool i, unsigned w) : isId(i), word(w) {} +}; + +// +// SPIR-V IR instruction. +// + +class Instruction { +public: + Instruction(Id resultId, Id typeId, Op opCode) : resultId(resultId), typeId(typeId), opCode(opCode), block(nullptr) { } + explicit Instruction(Op opCode) : resultId(NoResult), typeId(NoType), opCode(opCode), block(nullptr) { } + virtual ~Instruction() {} + void addIdOperand(Id id) { + operands.push_back(id); + idOperand.push_back(true); + } + void addImmediateOperand(unsigned int immediate) { + operands.push_back(immediate); + idOperand.push_back(false); + } + void setImmediateOperand(unsigned idx, unsigned int immediate) { + assert(!idOperand[idx]); + operands[idx] = immediate; + } + + void addStringOperand(const char* str) + { + unsigned int word; + char* wordString = (char*)&word; + char* wordPtr = wordString; + int charCount = 0; + char c; + do { + c = *(str++); + *(wordPtr++) = c; + ++charCount; + if (charCount == 4) { + addImmediateOperand(word); + wordPtr = wordString; + charCount = 0; + } + } while (c != 0); + + // deal with partial last word + if (charCount > 0) { + // pad with 0s + for (; charCount < 4; ++charCount) + *(wordPtr++) = 0; + addImmediateOperand(word); + } + } + bool isIdOperand(int op) const { return idOperand[op]; } + void setBlock(Block* b) { block = b; } + Block* getBlock() const { return block; } + Op getOpCode() const { return opCode; } + int getNumOperands() const + { + assert(operands.size() == idOperand.size()); + return (int)operands.size(); + } + Id getResultId() const { return resultId; } + Id getTypeId() const { return typeId; } + Id getIdOperand(int op) const { + assert(idOperand[op]); + return operands[op]; + } + unsigned int getImmediateOperand(int op) const { + assert(!idOperand[op]); + return operands[op]; + } + + // Write out the binary form. + void dump(std::vector& out) const + { + // Compute the wordCount + unsigned int wordCount = 1; + if (typeId) + ++wordCount; + if (resultId) + ++wordCount; + wordCount += (unsigned int)operands.size(); + + // Write out the beginning of the instruction + out.push_back(((wordCount) << WordCountShift) | opCode); + if (typeId) + out.push_back(typeId); + if (resultId) + out.push_back(resultId); + + // Write out the operands + for (int op = 0; op < (int)operands.size(); ++op) + out.push_back(operands[op]); + } + +protected: + Instruction(const Instruction&); + Id resultId; + Id typeId; + Op opCode; + std::vector operands; // operands, both and immediates (both are unsigned int) + std::vector idOperand; // true for operands that are , false for immediates + Block* block; +}; + +// +// SPIR-V IR block. +// + +class Block { +public: + Block(Id id, Function& parent); + virtual ~Block() + { + } + + Id getId() { return instructions.front()->getResultId(); } + + Function& getParent() const { return parent; } + void addInstruction(std::unique_ptr inst); + void addPredecessor(Block* pred) { predecessors.push_back(pred); pred->successors.push_back(this);} + void addLocalVariable(std::unique_ptr inst) { localVariables.push_back(std::move(inst)); } + const std::vector& getPredecessors() const { return predecessors; } + const std::vector& getSuccessors() const { return successors; } + const std::vector >& getInstructions() const { + return instructions; + } + const std::vector >& getLocalVariables() const { return localVariables; } + void setUnreachable() { unreachable = true; } + bool isUnreachable() const { return unreachable; } + // Returns the block's merge instruction, if one exists (otherwise null). + const Instruction* getMergeInstruction() const { + if (instructions.size() < 2) return nullptr; + const Instruction* nextToLast = (instructions.cend() - 2)->get(); + switch (nextToLast->getOpCode()) { + case OpSelectionMerge: + case OpLoopMerge: + return nextToLast; + default: + return nullptr; + } + return nullptr; + } + + // Change this block into a canonical dead merge block. Delete instructions + // as necessary. A canonical dead merge block has only an OpLabel and an + // OpUnreachable. + void rewriteAsCanonicalUnreachableMerge() { + assert(localVariables.empty()); + // Delete all instructions except for the label. + assert(instructions.size() > 0); + instructions.resize(1); + successors.clear(); + addInstruction(std::unique_ptr(new Instruction(OpUnreachable))); + } + // Change this block into a canonical dead continue target branching to the + // given header ID. Delete instructions as necessary. A canonical dead continue + // target has only an OpLabel and an unconditional branch back to the corresponding + // header. + void rewriteAsCanonicalUnreachableContinue(Block* header) { + assert(localVariables.empty()); + // Delete all instructions except for the label. + assert(instructions.size() > 0); + instructions.resize(1); + successors.clear(); + // Add OpBranch back to the header. + assert(header != nullptr); + Instruction* branch = new Instruction(OpBranch); + branch->addIdOperand(header->getId()); + addInstruction(std::unique_ptr(branch)); + successors.push_back(header); + } + + bool isTerminated() const + { + switch (instructions.back()->getOpCode()) { + case OpBranch: + case OpBranchConditional: + case OpSwitch: + case OpKill: + case OpReturn: + case OpReturnValue: + case OpUnreachable: + return true; + default: + return false; + } + } + + void dump(std::vector& out) const + { + instructions[0]->dump(out); + for (int i = 0; i < (int)localVariables.size(); ++i) + localVariables[i]->dump(out); + for (int i = 1; i < (int)instructions.size(); ++i) + instructions[i]->dump(out); + } + +protected: + Block(const Block&); + Block& operator=(Block&); + + // To enforce keeping parent and ownership in sync: + friend Function; + + std::vector > instructions; + std::vector predecessors, successors; + std::vector > localVariables; + Function& parent; + + // track whether this block is known to be uncreachable (not necessarily + // true for all unreachable blocks, but should be set at least + // for the extraneous ones introduced by the builder). + bool unreachable; +}; + +// The different reasons for reaching a block in the inReadableOrder traversal. +enum ReachReason { + // Reachable from the entry block via transfers of control, i.e. branches. + ReachViaControlFlow = 0, + // A continue target that is not reachable via control flow. + ReachDeadContinue, + // A merge block that is not reachable via control flow. + ReachDeadMerge +}; + +// Traverses the control-flow graph rooted at root in an order suited for +// readable code generation. Invokes callback at every node in the traversal +// order. The callback arguments are: +// - the block, +// - the reason we reached the block, +// - if the reason was that block is an unreachable continue or unreachable merge block +// then the last parameter is the corresponding header block. +void inReadableOrder(Block* root, std::function callback); + +// +// SPIR-V IR Function. +// + +class Function { +public: + Function(Id id, Id resultType, Id functionType, Id firstParam, Module& parent); + virtual ~Function() + { + for (int i = 0; i < (int)parameterInstructions.size(); ++i) + delete parameterInstructions[i]; + + for (int i = 0; i < (int)blocks.size(); ++i) + delete blocks[i]; + } + Id getId() const { return functionInstruction.getResultId(); } + Id getParamId(int p) const { return parameterInstructions[p]->getResultId(); } + Id getParamType(int p) const { return parameterInstructions[p]->getTypeId(); } + + void addBlock(Block* block) { blocks.push_back(block); } + void removeBlock(Block* block) + { + auto found = find(blocks.begin(), blocks.end(), block); + assert(found != blocks.end()); + blocks.erase(found); + delete block; + } + + Module& getParent() const { return parent; } + Block* getEntryBlock() const { return blocks.front(); } + Block* getLastBlock() const { return blocks.back(); } + const std::vector& getBlocks() const { return blocks; } + void addLocalVariable(std::unique_ptr inst); + Id getReturnType() const { return functionInstruction.getTypeId(); } + + void setImplicitThis() { implicitThis = true; } + bool hasImplicitThis() const { return implicitThis; } + + void dump(std::vector& out) const + { + // OpFunction + functionInstruction.dump(out); + + // OpFunctionParameter + for (int p = 0; p < (int)parameterInstructions.size(); ++p) + parameterInstructions[p]->dump(out); + + // Blocks + inReadableOrder(blocks[0], [&out](const Block* b, ReachReason, Block*) { b->dump(out); }); + Instruction end(0, 0, OpFunctionEnd); + end.dump(out); + } + +protected: + Function(const Function&); + Function& operator=(Function&); + + Module& parent; + Instruction functionInstruction; + std::vector parameterInstructions; + std::vector blocks; + bool implicitThis; // true if this is a member function expecting to be passed a 'this' as the first argument +}; + +// +// SPIR-V IR Module. +// + +class Module { +public: + Module() {} + virtual ~Module() + { + // TODO delete things + } + + void addFunction(Function *fun) { functions.push_back(fun); } + + void mapInstruction(Instruction *instruction) + { + spv::Id resultId = instruction->getResultId(); + // map the instruction's result id + if (resultId >= idToInstruction.size()) + idToInstruction.resize(resultId + 16); + idToInstruction[resultId] = instruction; + } + + Instruction* getInstruction(Id id) const { return idToInstruction[id]; } + const std::vector& getFunctions() const { return functions; } + spv::Id getTypeId(Id resultId) const { + return idToInstruction[resultId] == nullptr ? NoType : idToInstruction[resultId]->getTypeId(); + } + StorageClass getStorageClass(Id typeId) const + { + assert(idToInstruction[typeId]->getOpCode() == spv::OpTypePointer); + return (StorageClass)idToInstruction[typeId]->getImmediateOperand(0); + } + + void dump(std::vector& out) const + { + for (int f = 0; f < (int)functions.size(); ++f) + functions[f]->dump(out); + } + +protected: + Module(const Module&); + std::vector functions; + + // map from result id to instruction having that result id + std::vector idToInstruction; + + // map from a result id to its type id +}; + +// +// Implementation (it's here due to circular type definitions). +// + +// Add both +// - the OpFunction instruction +// - all the OpFunctionParameter instructions +__inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, Module& parent) + : parent(parent), functionInstruction(id, resultType, OpFunction), implicitThis(false) +{ + // OpFunction + functionInstruction.addImmediateOperand(FunctionControlMaskNone); + functionInstruction.addIdOperand(functionType); + parent.mapInstruction(&functionInstruction); + parent.addFunction(this); + + // OpFunctionParameter + Instruction* typeInst = parent.getInstruction(functionType); + int numParams = typeInst->getNumOperands() - 1; + for (int p = 0; p < numParams; ++p) { + Instruction* param = new Instruction(firstParamId + p, typeInst->getIdOperand(p + 1), OpFunctionParameter); + parent.mapInstruction(param); + parameterInstructions.push_back(param); + } +} + +__inline void Function::addLocalVariable(std::unique_ptr inst) +{ + Instruction* raw_instruction = inst.get(); + blocks[0]->addLocalVariable(std::move(inst)); + parent.mapInstruction(raw_instruction); +} + +__inline Block::Block(Id id, Function& parent) : parent(parent), unreachable(false) +{ + instructions.push_back(std::unique_ptr(new Instruction(id, NoType, OpLabel))); + instructions.back()->setBlock(this); + parent.getParent().mapInstruction(instructions.back().get()); +} + +__inline void Block::addInstruction(std::unique_ptr inst) +{ + Instruction* raw_instruction = inst.get(); + instructions.push_back(std::move(inst)); + raw_instruction->setBlock(this); + if (raw_instruction->getResultId()) + parent.getParent().mapInstruction(raw_instruction); +} + +} // end spv namespace + +#endif // spvIR_H diff --git a/ios/libs/libtbb_static.a b/ios/libs/libtbb_static.a index 63a01c7bcea878b275128a1d65c20274d7e925c5..f50228081c4ce60f54309765bbf15703acf6d76e 100644 GIT binary patch delta 247409 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

u)bEs)f!&bg1qW+Fm@IFSNZ@mLbhGD0 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%0Ao1!d5-I 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 delta 35 lcmZp;rE_Ah=tKjl_MmgDK+Fcj>_E%`#GKoM&T*}a0{|BP4^IF9 diff --git a/ios/libs/libtbbmalloc_proxy_static.a b/ios/libs/libtbbmalloc_proxy_static.a index 46c9dc93dcd4bf50b4844be418c340915503c9cf..c02dfe4cb68bafa91c44ee05ab0257d6a6c9b03e 100644 GIT binary patch literal 13032 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 delta 9 QcmaEnIzwmk1sMr302kr|-v9sr diff --git a/ios/libs/libtbbmalloc_static.a b/ios/libs/libtbbmalloc_static.a index bcefce793ea88ab74ec5c08cf422209ad22db6cb..287ae602c09aec7b4a83ae4f9ea16c96cbeecc73 100644 GIT binary patch literal 253144 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 delta 16 XcmcbylfR>nz5RkH)AkFZ%pAu7J@5va diff --git a/mac/libs/libtbb_static.a b/mac/libs/libtbb_static.a index 791b7196abb538ef4faf4264233c0025b1b334d7..53bea733311e235c78abee86914a0d1d15d10530 100644 GIT binary patch delta 228526 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 delta 8 Pcmey6I>U0K!3-Gy6PN?M diff --git a/mac/libs/libtbbmalloc_static.a b/mac/libs/libtbbmalloc_static.a index 7d869ffaf38e335e185bb135008b463676ec5d24..80a14fb5c627d9c0e2a9ce5ec6e00ce686807c8a 100644 GIT binary patch delta 85212 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 z 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 lk9sa2PEqY^%iYo2*MC24d(l%_+fU_&Gvp