浏览代码

update glslang to KhronosGroup/glslang@05cfcc1

Fixes #2194.
Sasha Szpakowski 1 月之前
父节点
当前提交
1f1728c333
共有 65 个文件被更改,包括 11810 次插入7310 次删除
  1. 3 1
      CMakeLists.txt
  2. 19 11
      platform/xcode/liblove.xcodeproj/project.pbxproj
  3. 1 0
      src/libraries/glslang/SPIRV/GLSL.ext.EXT.h
  4. 3 0
      src/libraries/glslang/SPIRV/GLSL.ext.KHR.h
  5. 15 4
      src/libraries/glslang/SPIRV/GLSL.ext.NV.h
  6. 7 4
      src/libraries/glslang/SPIRV/GLSL.ext.QCOM.h
  7. 349 300
      src/libraries/glslang/SPIRV/GlslangToSpv.cpp
  8. 9 8
      src/libraries/glslang/SPIRV/GlslangToSpv.h
  9. 1 1
      src/libraries/glslang/SPIRV/InReadableOrder.cpp
  10. 2 1
      src/libraries/glslang/SPIRV/Logger.h
  11. 197 161
      src/libraries/glslang/SPIRV/SPVRemapper.cpp
  12. 19 3
      src/libraries/glslang/SPIRV/SPVRemapper.h
  13. 337 133
      src/libraries/glslang/SPIRV/SpvBuilder.cpp
  14. 91 45
      src/libraries/glslang/SPIRV/SpvBuilder.h
  15. 116 115
      src/libraries/glslang/SPIRV/SpvPostProcess.cpp
  16. 9 1
      src/libraries/glslang/SPIRV/SpvTools.cpp
  17. 22 18
      src/libraries/glslang/SPIRV/SpvTools.h
  18. 126 66
      src/libraries/glslang/SPIRV/disassemble.cpp
  19. 3 1
      src/libraries/glslang/SPIRV/disassemble.h
  20. 566 454
      src/libraries/glslang/SPIRV/doc.cpp
  21. 2 1
      src/libraries/glslang/SPIRV/doc.h
  22. 94 0
      src/libraries/glslang/SPIRV/hex_float.h
  23. 0 2827
      src/libraries/glslang/SPIRV/spirv.hpp
  24. 5186 0
      src/libraries/glslang/SPIRV/spirv.hpp11
  25. 106 32
      src/libraries/glslang/SPIRV/spvIR.h
  26. 88 0
      src/libraries/glslang/SPIRV/spvUtil.h
  27. 58 0
      src/libraries/glslang/glslang/Include/BaseTypes.h
  28. 5 0
      src/libraries/glslang/glslang/Include/PoolAlloc.h
  29. 182 51
      src/libraries/glslang/glslang/Include/Types.h
  30. 95 187
      src/libraries/glslang/glslang/Include/intermediate.h
  31. 54 0
      src/libraries/glslang/glslang/Include/visibility.h
  32. 184 271
      src/libraries/glslang/glslang/MachineIndependent/Constant.cpp
  33. 576 278
      src/libraries/glslang/glslang/MachineIndependent/Initialize.cpp
  34. 200 331
      src/libraries/glslang/glslang/MachineIndependent/Intermediate.cpp
  35. 41 0
      src/libraries/glslang/glslang/MachineIndependent/LiveTraverser.h
  36. 5 0
      src/libraries/glslang/glslang/MachineIndependent/ParseContextBase.cpp
  37. 544 54
      src/libraries/glslang/glslang/MachineIndependent/ParseHelper.cpp
  38. 5 3
      src/libraries/glslang/glslang/MachineIndependent/ParseHelper.h
  39. 493 493
      src/libraries/glslang/glslang/MachineIndependent/Scan.cpp
  40. 98 42
      src/libraries/glslang/glslang/MachineIndependent/ShaderLang.cpp
  41. 27 1
      src/libraries/glslang/glslang/MachineIndependent/SymbolTable.cpp
  42. 7 3
      src/libraries/glslang/glslang/MachineIndependent/SymbolTable.h
  43. 117 11
      src/libraries/glslang/glslang/MachineIndependent/Versions.cpp
  44. 18 0
      src/libraries/glslang/glslang/MachineIndependent/Versions.h
  45. 551 534
      src/libraries/glslang/glslang/MachineIndependent/glslang_tab.cpp
  46. 420 403
      src/libraries/glslang/glslang/MachineIndependent/glslang_tab.cpp.h
  47. 84 186
      src/libraries/glslang/glslang/MachineIndependent/intermOut.cpp
  48. 142 5
      src/libraries/glslang/glslang/MachineIndependent/iomapper.cpp
  49. 7 143
      src/libraries/glslang/glslang/MachineIndependent/iomapper.h
  50. 377 80
      src/libraries/glslang/glslang/MachineIndependent/linkValidate.cpp
  51. 54 10
      src/libraries/glslang/glslang/MachineIndependent/localintermediate.h
  52. 6 0
      src/libraries/glslang/glslang/MachineIndependent/parseVersions.h
  53. 4 2
      src/libraries/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp
  54. 2 1
      src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp
  55. 4 1
      src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpContext.h
  56. 1 0
      src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp
  57. 3 0
      src/libraries/glslang/glslang/MachineIndependent/propagateNoContraction.cpp
  58. 2 1
      src/libraries/glslang/glslang/MachineIndependent/propagateNoContraction.h
  59. 10 3
      src/libraries/glslang/glslang/MachineIndependent/reflection.cpp
  60. 10 3
      src/libraries/glslang/glslang/MachineIndependent/reflection.h
  61. 2 1
      src/libraries/glslang/glslang/OSDependent/osinclude.h
  62. 5 4
      src/libraries/glslang/glslang/Public/ResourceLimits.h
  63. 43 18
      src/libraries/glslang/glslang/Public/ShaderLang.h
  64. 2 2
      src/libraries/glslang/glslang/build_info.h
  65. 1 1
      src/modules/graphics/Shader.cpp

+ 3 - 1
CMakeLists.txt

@@ -1412,6 +1412,7 @@ add_library(love_3p_glslang
 	src/libraries/glslang/glslang/Include/ShHandle.h
 	src/libraries/glslang/glslang/Include/SpirvIntrinsics.h
 	src/libraries/glslang/glslang/Include/Types.h
+	src/libraries/glslang/glslang/Include/visibility.h
 	src/libraries/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp
 	src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpAtom.cpp
 	src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp
@@ -1484,10 +1485,11 @@ add_library(love_3p_glslang
 	src/libraries/glslang/SPIRV/Logger.h
 	src/libraries/glslang/SPIRV/NonSemanticDebugPrintf.h
 	src/libraries/glslang/SPIRV/NonSemanticShaderDebugInfo100.h
-	src/libraries/glslang/SPIRV/spirv.hpp
+	src/libraries/glslang/SPIRV/spirv.hpp11
 	src/libraries/glslang/SPIRV/SpvBuilder.cpp
 	src/libraries/glslang/SPIRV/SpvBuilder.h
 	src/libraries/glslang/SPIRV/spvIR.h
+	src/libraries/glslang/SPIRV/spvUtil.h
 	src/libraries/glslang/SPIRV/SpvPostProcess.cpp
 	src/libraries/glslang/SPIRV/SPVRemapper.cpp
 	src/libraries/glslang/SPIRV/SPVRemapper.h

+ 19 - 11
platform/xcode/liblove.xcodeproj/project.pbxproj

@@ -50,6 +50,9 @@
 		217DFC101D9F6D490055D849 /* url.lua.h in Headers */ = {isa = PBXBuildFile; fileRef = 217DFBD41D9F6D490055D849 /* url.lua.h */; };
 		217DFC111D9F6D490055D849 /* usocket.c in Sources */ = {isa = PBXBuildFile; fileRef = 217DFBD51D9F6D490055D849 /* usocket.c */; };
 		217DFC121D9F6D490055D849 /* usocket.h in Headers */ = {isa = PBXBuildFile; fileRef = 217DFBD61D9F6D490055D849 /* usocket.h */; };
+		D91C76122DE3D088001FC408 /* spvUtil.h in Headers */ = {isa = PBXBuildFile; fileRef = D91C76112DE3D088001FC408 /* spvUtil.h */; };
+		D91C76132DE3D088001FC408 /* spirv.hpp11 in Resources */ = {isa = PBXBuildFile; fileRef = D91C76102DE3D088001FC408 /* spirv.hpp11 */; };
+		D91C76152DE3D0A2001FC408 /* visibility.h in Headers */ = {isa = PBXBuildFile; fileRef = D91C76142DE3D0A2001FC408 /* visibility.h */; };
 		D923E7D3296B85B9002FF1B3 /* harfbuzz.xcframework in Frameworks */ = {isa = PBXBuildFile; fileRef = D923E7D2296B85B9002FF1B3 /* harfbuzz.xcframework */; };
 		D93660F82D1C727C00C0EC4B /* Touch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D93660F72D1C727C00C0EC4B /* Touch.cpp */; };
 		D93660F92D1C727C00C0EC4B /* Touch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D93660F72D1C727C00C0EC4B /* Touch.cpp */; };
@@ -1317,7 +1320,6 @@
 		FAF6C9E223C2DE2900D7B5BC /* InReadableOrder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FAF6C9C623C2DE2900D7B5BC /* InReadableOrder.cpp */; };
 		FAF6C9E323C2DE2900D7B5BC /* GLSL.ext.AMD.h in Headers */ = {isa = PBXBuildFile; fileRef = FAF6C9C723C2DE2900D7B5BC /* GLSL.ext.AMD.h */; };
 		FAF6C9E423C2DE2900D7B5BC /* doc.h in Headers */ = {isa = PBXBuildFile; fileRef = FAF6C9C823C2DE2900D7B5BC /* doc.h */; };
-		FAF6C9E523C2DE2900D7B5BC /* spirv.hpp in Headers */ = {isa = PBXBuildFile; fileRef = FAF6C9C923C2DE2900D7B5BC /* spirv.hpp */; };
 		FAF6C9E623C2DE2900D7B5BC /* SpvBuilder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FAF6C9CA23C2DE2900D7B5BC /* SpvBuilder.cpp */; };
 		FAF6C9E723C2DE2900D7B5BC /* SpvBuilder.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FAF6C9CA23C2DE2900D7B5BC /* SpvBuilder.cpp */; };
 		FAF6C9E823C2DE2900D7B5BC /* GLSL.ext.EXT.h in Headers */ = {isa = PBXBuildFile; fileRef = FAF6C9CB23C2DE2900D7B5BC /* GLSL.ext.EXT.h */; };
@@ -1414,6 +1416,9 @@
 		217DFBD41D9F6D490055D849 /* url.lua.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = url.lua.h; sourceTree = "<group>"; };
 		217DFBD51D9F6D490055D849 /* usocket.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = usocket.c; sourceTree = "<group>"; };
 		217DFBD61D9F6D490055D849 /* usocket.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = usocket.h; sourceTree = "<group>"; };
+		D91C76102DE3D088001FC408 /* spirv.hpp11 */ = {isa = PBXFileReference; lastKnownFileType = text; path = spirv.hpp11; sourceTree = "<group>"; };
+		D91C76112DE3D088001FC408 /* spvUtil.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = spvUtil.h; sourceTree = "<group>"; };
+		D91C76142DE3D0A2001FC408 /* visibility.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = visibility.h; sourceTree = "<group>"; };
 		D923E7D2296B85B9002FF1B3 /* harfbuzz.xcframework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcframework; name = harfbuzz.xcframework; path = ios/libraries/harfbuzz.xcframework; sourceTree = "<group>"; };
 		D93660F72D1C727C00C0EC4B /* Touch.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Touch.cpp; sourceTree = "<group>"; };
 		D943E58C2A24D56000D80361 /* PhysfsIo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PhysfsIo.cpp; sourceTree = "<group>"; };
@@ -2296,7 +2301,6 @@
 		FAF6C9C623C2DE2900D7B5BC /* InReadableOrder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InReadableOrder.cpp; sourceTree = "<group>"; };
 		FAF6C9C723C2DE2900D7B5BC /* GLSL.ext.AMD.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GLSL.ext.AMD.h; sourceTree = "<group>"; };
 		FAF6C9C823C2DE2900D7B5BC /* doc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = doc.h; sourceTree = "<group>"; };
-		FAF6C9C923C2DE2900D7B5BC /* spirv.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = spirv.hpp; sourceTree = "<group>"; };
 		FAF6C9CA23C2DE2900D7B5BC /* SpvBuilder.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SpvBuilder.cpp; sourceTree = "<group>"; };
 		FAF6C9CB23C2DE2900D7B5BC /* GLSL.ext.EXT.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GLSL.ext.EXT.h; sourceTree = "<group>"; };
 		FAF6C9CC23C2DE2900D7B5BC /* GLSL.ext.KHR.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GLSL.ext.KHR.h; sourceTree = "<group>"; };
@@ -3959,6 +3963,7 @@
 				FAF13FD01E20934C00F898D2 /* ShHandle.h */,
 				FA84DE5D2778D7DB002674C6 /* SpirvIntrinsics.h */,
 				FAF13FD11E20934C00F898D2 /* Types.h */,
+				D91C76142DE3D0A2001FC408 /* visibility.h */,
 			);
 			path = Include;
 			sourceTree = "<group>";
@@ -4056,10 +4061,10 @@
 			isa = PBXGroup;
 			children = (
 				FAF6C9D023C2DE2900D7B5BC /* bitutils.h */,
-				FAF6C9D923C2DE2900D7B5BC /* disassemble.cpp */,
 				FAF6C9D123C2DE2900D7B5BC /* disassemble.h */,
-				FAF6C9D823C2DE2900D7B5BC /* doc.cpp */,
+				FAF6C9D923C2DE2900D7B5BC /* disassemble.cpp */,
 				FAF6C9C823C2DE2900D7B5BC /* doc.h */,
+				FAF6C9D823C2DE2900D7B5BC /* doc.cpp */,
 				FAF6C9C723C2DE2900D7B5BC /* GLSL.ext.AMD.h */,
 				D9DB6E3A2B4B41570037A1F6 /* GLSL.ext.ARM.h */,
 				FAF6C9CB23C2DE2900D7B5BC /* GLSL.ext.EXT.h */,
@@ -4067,23 +4072,24 @@
 				FAF6C9CD23C2DE2900D7B5BC /* GLSL.ext.NV.h */,
 				D9DB6E3B2B4B41580037A1F6 /* GLSL.ext.QCOM.h */,
 				FAF6C9D323C2DE2900D7B5BC /* GLSL.std.450.h */,
-				FAF6C9CE23C2DE2900D7B5BC /* GlslangToSpv.cpp */,
 				FAF6C9D223C2DE2900D7B5BC /* GlslangToSpv.h */,
+				FAF6C9CE23C2DE2900D7B5BC /* GlslangToSpv.cpp */,
 				FAF6C9D623C2DE2900D7B5BC /* hex_float.h */,
 				FAF6C9C623C2DE2900D7B5BC /* InReadableOrder.cpp */,
-				FAF6C9D523C2DE2900D7B5BC /* Logger.cpp */,
 				FAF6C9D723C2DE2900D7B5BC /* Logger.h */,
+				FAF6C9D523C2DE2900D7B5BC /* Logger.cpp */,
 				D9DB6E382B4B41570037A1F6 /* NonSemanticDebugPrintf.h */,
 				D9DB6E392B4B41570037A1F6 /* NonSemanticShaderDebugInfo100.h */,
-				FAF6C9C923C2DE2900D7B5BC /* spirv.hpp */,
-				FAF6C9CA23C2DE2900D7B5BC /* SpvBuilder.cpp */,
+				D91C76102DE3D088001FC408 /* spirv.hpp11 */,
 				FAF6C9C223C2DE2900D7B5BC /* SpvBuilder.h */,
+				FAF6C9CA23C2DE2900D7B5BC /* SpvBuilder.cpp */,
 				FAF6C9CF23C2DE2900D7B5BC /* spvIR.h */,
 				FAF6C9C323C2DE2900D7B5BC /* SpvPostProcess.cpp */,
-				FAF6C9D423C2DE2900D7B5BC /* SPVRemapper.cpp */,
 				FAF6C9C123C2DE2900D7B5BC /* SPVRemapper.h */,
-				FAF6C9C523C2DE2900D7B5BC /* SpvTools.cpp */,
+				FAF6C9D423C2DE2900D7B5BC /* SPVRemapper.cpp */,
 				FAF6C9C423C2DE2900D7B5BC /* SpvTools.h */,
+				FAF6C9C523C2DE2900D7B5BC /* SpvTools.cpp */,
+				D91C76112DE3D088001FC408 /* spvUtil.h */,
 			);
 			path = SPIRV;
 			sourceTree = "<group>";
@@ -4204,7 +4210,6 @@
 				FA0B7EDE1A95902D000E1D17 /* Touch.h in Headers */,
 				FAC7CD861FE35E95006A60C7 /* physfs.h in Headers */,
 				D9DAB92C2961F10000C64820 /* TextShaper.h in Headers */,
-				FAF6C9E523C2DE2900D7B5BC /* spirv.hpp in Headers */,
 				FA522D4F23F9FE380059EE3C /* MP3Decoder.h in Headers */,
 				217DFBEE1D9F6D490055D849 /* luasocket.h in Headers */,
 				FACA02F31F5E396B0084B28F /* HashFunction.h in Headers */,
@@ -4268,6 +4273,7 @@
 				FA0B7DAD1A95902C000E1D17 /* STBHandler.h in Headers */,
 				FABDA9BB2552448300B5C523 /* b2_dynamic_tree.h in Headers */,
 				FA1BA0A41E16D97500AA2803 /* wrap_Font.h in Headers */,
+				D91C76122DE3D088001FC408 /* spvUtil.h in Headers */,
 				FA0B7DE11A95902C000E1D17 /* wrap_Math.h in Headers */,
 				FA0B7D1A1A95902C000E1D17 /* TrueTypeRasterizer.h in Headers */,
 				FA0B7EA81A95902C000E1D17 /* wrap_Decoder.h in Headers */,
@@ -4488,6 +4494,7 @@
 				FA0B793D1A958E3B000E1D17 /* runtime.h in Headers */,
 				FAF6C9E323C2DE2900D7B5BC /* GLSL.ext.AMD.h in Headers */,
 				FA57FB9A1AE1993600F2AD6D /* noise1234.h in Headers */,
+				D91C76152DE3D0A2001FC408 /* visibility.h in Headers */,
 				FACA02EF1F5E396B0084B28F /* Compressor.h in Headers */,
 				FA0B7CED1A95902C000E1D17 /* Event.h in Headers */,
 				FA0B7D811A95902C000E1D17 /* Volatile.h in Headers */,
@@ -4638,6 +4645,7 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				D91C76132DE3D088001FC408 /* spirv.hpp11 in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

+ 1 - 0
src/libraries/glslang/SPIRV/GLSL.ext.EXT.h

@@ -42,5 +42,6 @@ static const char* const E_SPV_EXT_shader_image_int64 = "SPV_EXT_shader_image_in
 static const char* const E_SPV_EXT_shader_tile_image = "SPV_EXT_shader_tile_image";
 static const char* const E_SPV_EXT_mesh_shader = "SPV_EXT_mesh_shader";
 static const char* const E_SPV_ARM_cooperative_matrix_layouts = "SPV_ARM_cooperative_matrix_layouts";
+static const char* const E_SPV_EXT_float8 = "SPV_EXT_float8";
 
 #endif  // #ifndef GLSLextEXT_H

+ 3 - 0
src/libraries/glslang/SPIRV/GLSL.ext.KHR.h

@@ -63,5 +63,8 @@ static const char* const E_SPV_KHR_subgroup_rotate              = "SPV_KHR_subgr
 static const char* const E_SPV_KHR_expect_assume                = "SPV_KHR_expect_assume";
 static const char* const E_SPV_EXT_replicated_composites        = "SPV_EXT_replicated_composites";
 static const char* const E_SPV_KHR_relaxed_extended_instruction = "SPV_KHR_relaxed_extended_instruction";
+static const char* const E_SPV_KHR_integer_dot_product          = "SPV_KHR_integer_dot_product";
+static const char* const E_SPV_NV_cooperative_vector            = "SPV_NV_cooperative_vector";
+static const char* const E_SPV_KHR_bfloat16                     = "SPV_KHR_bfloat16";
 
 #endif  // #ifndef GLSLextKHR_H

+ 15 - 4
src/libraries/glslang/SPIRV/GLSL.ext.NV.h

@@ -27,10 +27,10 @@
 #ifndef GLSLextNV_H
 #define GLSLextNV_H
 
-enum BuiltIn;
-enum Decoration;
-enum Op;
-enum Capability;
+enum class BuiltIn : unsigned;
+enum class Decoration : unsigned;
+enum class Op : unsigned;
+enum class Capability : unsigned;
 
 static const int GLSLextNVVersion = 100;
 static const int GLSLextNVRevision = 11;
@@ -90,4 +90,15 @@ const char* const E_SPV_NV_displacement_micromap = "SPV_NV_displacement_micromap
 //SPV_NV_shader_atomic_fp16_vector
 const char* const E_SPV_NV_shader_atomic_fp16_vector = "SPV_NV_shader_atomic_fp16_vector";
 
+//SPV_NV_tensor_addressing
+const char* const E_SPV_NV_tensor_addressing = "SPV_NV_tensor_addressing";
+
+//SPV_NV_cooperative_matrix2
+const char* const E_SPV_NV_cooperative_matrix2 = "SPV_NV_cooperative_matrix2";
+
+//SPV_NV_cluster_acceleration_structure
+const char* const E_SPV_NV_cluster_acceleration_structure = "SPV_NV_cluster_acceleration_structure";
+
+//SPV_NV_linear_swept_spheres
+const char* const E_SPV_NV_linear_swept_spheres = "SPV_NV_linear_swept_spheres";
 #endif  // #ifndef GLSLextNV_H

+ 7 - 4
src/libraries/glslang/SPIRV/GLSL.ext.QCOM.h

@@ -27,10 +27,10 @@
 #ifndef GLSLextQCOM_H
 #define GLSLextQCOM_H
 
-enum BuiltIn;
-enum Decoration;
-enum Op;
-enum Capability;
+enum class BuiltIn : unsigned;
+enum class Decoration : unsigned;
+enum class Op : unsigned;
+enum class Capability : unsigned;
 
 static const int GLSLextQCOMVersion = 100;
 static const int GLSLextQCOMRevision = 1;
@@ -40,4 +40,7 @@ const char* const E_SPV_QCOM_image_processing = "SPV_QCOM_image_processing";
 //SPV_QCOM_image_processing2
 const char* const E_SPV_QCOM_image_processing2 = "SPV_QCOM_image_processing2";
 
+//SPV_QCOM_tile_shading
+const char* const E_SPV_QCOM_tile_shading = "SPV_QCOM_tile_shading";
+
 #endif  // #ifndef GLSLextQCOM_H

文件差异内容过多而无法显示
+ 349 - 300
src/libraries/glslang/SPIRV/GlslangToSpv.cpp


+ 9 - 8
src/libraries/glslang/SPIRV/GlslangToSpv.h

@@ -39,6 +39,7 @@
 #include <vector>
 
 #include "Logger.h"
+#include "../glslang/Include/visibility.h"
 
 namespace glslang {
 class TIntermediate;
@@ -56,13 +57,13 @@ struct SpvOptions {
     bool optimizerAllowExpandedIDBound{false};
 };
 
-void GetSpirvVersion(std::string&);
-int GetSpirvGeneratorVersion();
-void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                  SpvOptions* options = nullptr);
-void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                  spv::SpvBuildLogger* logger, SpvOptions* options = nullptr);
-bool OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
-bool OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
+GLSLANG_EXPORT void GetSpirvVersion(std::string&);
+GLSLANG_EXPORT int GetSpirvGeneratorVersion();
+GLSLANG_EXPORT void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                 SpvOptions* options = nullptr);
+GLSLANG_EXPORT void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                 spv::SpvBuildLogger* logger, SpvOptions* options = nullptr);
+GLSLANG_EXPORT bool OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName);
+GLSLANG_EXPORT bool OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName);
 
 }

+ 1 - 1
src/libraries/glslang/SPIRV/InReadableOrder.cpp

@@ -85,7 +85,7 @@ public:
             Id mergeId = mergeInst->getIdOperand(0);
             mergeBlock = block->getParent().getParent().getInstruction(mergeId)->getBlock();
             delayed_.insert(mergeBlock);
-            if (mergeInst->getOpCode() == spv::OpLoopMerge) {
+            if (mergeInst->getOpCode() == spv::Op::OpLoopMerge) {
                 Id continueId = mergeInst->getIdOperand(1);
                 continueBlock =
                     block->getParent().getParent().getInstruction(continueId)->getBlock();

+ 2 - 1
src/libraries/glslang/SPIRV/Logger.h

@@ -37,12 +37,13 @@
 
 #include <string>
 #include <vector>
+#include "../glslang/Include/visibility.h"
 
 namespace spv {
 
 // A class for holding all SPIR-V build status messages, including
 // missing/TBD functionalities, warnings, and errors.
-class SpvBuildLogger {
+class GLSLANG_EXPORT SpvBuildLogger {
 public:
     SpvBuildLogger() {}
 

+ 197 - 161
src/libraries/glslang/SPIRV/SPVRemapper.cpp

@@ -35,10 +35,10 @@
 
 #include "SPVRemapper.h"
 #include "doc.h"
+#include "spvUtil.h"
 
 #include <algorithm>
 #include <cassert>
-#include "../glslang/Include/Common.h"
 
 namespace spv {
 
@@ -62,13 +62,13 @@ namespace spv {
         std::uint32_t offset = 0;
 
         switch (opCode) {
-        case spv::OpExtInst:
+        case spv::Op::OpExtInst:
             offset += asId(word + 4); break;
         default:
             break;
         }
 
-        return opCode * 19 + offset; // 19 = small prime
+        return ((unsigned)opCode) * 19 + offset; // 19 = small prime
     }
 
     spirvbin_t::range_t spirvbin_t::literalRange(spv::Op opCode) const
@@ -76,16 +76,16 @@ namespace spv {
         static const int maxCount = 1<<30;
 
         switch (opCode) {
-        case spv::OpTypeFloat:        // fall through...
-        case spv::OpTypePointer:      return range_t(2, 3);
-        case spv::OpTypeInt:          return range_t(2, 4);
+        case spv::Op::OpTypeFloat:    // fall through...
+        case spv::Op::OpTypePointer:  return range_t(2, 3);
+        case spv::Op::OpTypeInt:      return range_t(2, 4);
         // TODO: case spv::OpTypeImage:
         // TODO: case spv::OpTypeSampledImage:
-        case spv::OpTypeSampler:      return range_t(3, 8);
-        case spv::OpTypeVector:       // fall through
-        case spv::OpTypeMatrix:       // ...
-        case spv::OpTypePipe:         return range_t(3, 4);
-        case spv::OpConstant:         return range_t(3, maxCount);
+        case spv::Op::OpTypeSampler:  return range_t(3, 8);
+        case spv::Op::OpTypeVector:   // fall through
+        case spv::Op::OpTypeMatrix:   // ...
+        case spv::Op::OpTypePipe:     return range_t(3, 4);
+        case spv::Op::OpConstant:     return range_t(3, maxCount);
         default:                      return range_t(0, 0);
         }
     }
@@ -98,15 +98,15 @@ namespace spv {
             return range_t(1, 2);
 
         switch (opCode) {
-        case spv::OpTypeVector:       // fall through
-        case spv::OpTypeMatrix:       // ...
-        case spv::OpTypeSampler:      // ...
-        case spv::OpTypeArray:        // ...
-        case spv::OpTypeRuntimeArray: // ...
-        case spv::OpTypePipe:         return range_t(2, 3);
-        case spv::OpTypeStruct:       // fall through
-        case spv::OpTypeFunction:     return range_t(2, maxCount);
-        case spv::OpTypePointer:      return range_t(3, 4);
+        case spv::Op::OpTypeVector:       // fall through
+        case spv::Op::OpTypeMatrix:       // ...
+        case spv::Op::OpTypeSampler:      // ...
+        case spv::Op::OpTypeArray:        // ...
+        case spv::Op::OpTypeRuntimeArray: // ...
+        case spv::Op::OpTypePipe:         return range_t(2, 3);
+        case spv::Op::OpTypeStruct:       // fall through
+        case spv::Op::OpTypeFunction:     return range_t(2, maxCount);
+        case spv::Op::OpTypePointer:      return range_t(3, 4);
         default:                      return range_t(0, 0);
         }
     }
@@ -116,9 +116,9 @@ namespace spv {
         static const int maxCount = 1<<30;
 
         switch (opCode) {
-        case spv::OpTypeArray:         // fall through...
-        case spv::OpTypeRuntimeArray:  return range_t(3, 4);
-        case spv::OpConstantComposite: return range_t(3, maxCount);
+        case spv::Op::OpTypeArray:         // fall through...
+        case spv::Op::OpTypeRuntimeArray:  return range_t(3, 4);
+        case spv::Op::OpConstantComposite: return range_t(3, maxCount);
         default:                       return range_t(0, 0);
         }
     }
@@ -135,8 +135,8 @@ namespace spv {
             return 0;
 
         switch (opCode) {
-        case spv::OpTypeInt:   // fall through...
-        case spv::OpTypeFloat: return (spv[typeStart+2]+31)/32;
+        case spv::Op::OpTypeInt:   // fall through...
+        case spv::Op::OpTypeFloat: return (spv[typeStart + 2] + 31) / 32;
         default:
             return 0;
         }
@@ -159,11 +159,11 @@ namespace spv {
     bool spirvbin_t::isStripOp(spv::Op opCode, unsigned start) const
     {
         switch (opCode) {
-        case spv::OpSource:
-        case spv::OpSourceExtension:
-        case spv::OpName:
-        case spv::OpMemberName:
-        case spv::OpLine :
+        case spv::Op::OpSource:
+        case spv::Op::OpSourceExtension:
+        case spv::Op::OpName:
+        case spv::Op::OpMemberName:
+        case spv::Op::OpLine:
         {
             const std::string name = literalString(start + 2);
 
@@ -186,15 +186,15 @@ namespace spv {
     bool spirvbin_t::isFlowCtrl(spv::Op opCode) const
     {
         switch (opCode) {
-        case spv::OpBranchConditional:
-        case spv::OpBranch:
-        case spv::OpSwitch:
-        case spv::OpLoopMerge:
-        case spv::OpSelectionMerge:
-        case spv::OpLabel:
-        case spv::OpFunction:
-        case spv::OpFunctionEnd:    return true;
-        default:                    return false;
+        case spv::Op::OpBranchConditional:
+        case spv::Op::OpBranch:
+        case spv::Op::OpSwitch:
+        case spv::Op::OpLoopMerge:
+        case spv::Op::OpSelectionMerge:
+        case spv::Op::OpLabel:
+        case spv::Op::OpFunction:
+        case spv::Op::OpFunctionEnd: return true;
+        default:                     return false;
         }
     }
 
@@ -202,27 +202,27 @@ namespace spv {
     bool spirvbin_t::isTypeOp(spv::Op opCode) const
     {
         switch (opCode) {
-        case spv::OpTypeVoid:
-        case spv::OpTypeBool:
-        case spv::OpTypeInt:
-        case spv::OpTypeFloat:
-        case spv::OpTypeVector:
-        case spv::OpTypeMatrix:
-        case spv::OpTypeImage:
-        case spv::OpTypeSampler:
-        case spv::OpTypeArray:
-        case spv::OpTypeRuntimeArray:
-        case spv::OpTypeStruct:
-        case spv::OpTypeOpaque:
-        case spv::OpTypePointer:
-        case spv::OpTypeFunction:
-        case spv::OpTypeEvent:
-        case spv::OpTypeDeviceEvent:
-        case spv::OpTypeReserveId:
-        case spv::OpTypeQueue:
-        case spv::OpTypeSampledImage:
-        case spv::OpTypePipe:         return true;
-        default:                      return false;
+        case spv::Op::OpTypeVoid:
+        case spv::Op::OpTypeBool:
+        case spv::Op::OpTypeInt:
+        case spv::Op::OpTypeFloat:
+        case spv::Op::OpTypeVector:
+        case spv::Op::OpTypeMatrix:
+        case spv::Op::OpTypeImage:
+        case spv::Op::OpTypeSampler:
+        case spv::Op::OpTypeArray:
+        case spv::Op::OpTypeRuntimeArray:
+        case spv::Op::OpTypeStruct:
+        case spv::Op::OpTypeOpaque:
+        case spv::Op::OpTypePointer:
+        case spv::Op::OpTypeFunction:
+        case spv::Op::OpTypeEvent:
+        case spv::Op::OpTypeDeviceEvent:
+        case spv::Op::OpTypeReserveId:
+        case spv::Op::OpTypeQueue:
+        case spv::Op::OpTypeSampledImage:
+        case spv::Op::OpTypePipe:         return true;
+        default:                          return false;
         }
     }
 
@@ -230,15 +230,15 @@ namespace spv {
     bool spirvbin_t::isConstOp(spv::Op opCode) const
     {
         switch (opCode) {
-        case spv::OpConstantSampler:
+        case spv::Op::OpConstantSampler:
             error("unimplemented constant type");
             return true;
 
-        case spv::OpConstantNull:
-        case spv::OpConstantTrue:
-        case spv::OpConstantFalse:
-        case spv::OpConstantComposite:
-        case spv::OpConstant:
+        case spv::Op::OpConstantNull:
+        case spv::Op::OpConstantTrue:
+        case spv::Op::OpConstantFalse:
+        case spv::Op::OpConstantComposite:
+        case spv::Op::OpConstant:
             return true;
 
         default:
@@ -396,10 +396,10 @@ namespace spv {
             [&](spv::Op opCode, unsigned start) {
                 // strip opcodes pointing to removed data
                 switch (opCode) {
-                case spv::OpName:
-                case spv::OpMemberName:
-                case spv::OpDecorate:
-                case spv::OpMemberDecorate:
+                case spv::Op::OpName:
+                case spv::Op::OpMemberName:
+                case spv::Op::OpDecorate:
+                case spv::Op::OpMemberDecorate:
                     if (idPosR.find(asId(start+1)) == idPosR.end())
                         stripInst(start);
                     break;
@@ -440,11 +440,11 @@ namespace spv {
                 unsigned word = start+1;
                 spv::Id  typeId = spv::NoResult;
 
-                if (spv::InstructionDesc[opCode].hasType())
+                if (spv::InstructionDesc[enumCast(opCode)].hasType())
                     typeId = asId(word++);
 
                 // If there's a result ID, remember the size of its type
-                if (spv::InstructionDesc[opCode].hasResult()) {
+                if (spv::InstructionDesc[enumCast(opCode)].hasResult()) {
                     const spv::Id resultId = asId(word++);
                     idPosR[resultId] = start;
 
@@ -547,19 +547,19 @@ namespace spv {
             return nextInst;
 
         // Read type and result ID from instruction desc table
-        if (spv::InstructionDesc[opCode].hasType()) {
+        if (spv::InstructionDesc[enumCast(opCode)].hasType()) {
             idFn(asId(word++));
             --numOperands;
         }
 
-        if (spv::InstructionDesc[opCode].hasResult()) {
+        if (spv::InstructionDesc[enumCast(opCode)].hasResult()) {
             idFn(asId(word++));
             --numOperands;
         }
 
         // Extended instructions: currently, assume everything is an ID.
         // TODO: add whatever data we need for exceptions to that
-        if (opCode == spv::OpExtInst) {
+        if (opCode == spv::Op::OpExtInst) {
 
             idFn(asId(word)); // Instruction set is an ID that also needs to be mapped
 
@@ -584,14 +584,14 @@ namespace spv {
             // opcode being processed is the literal opcode value of the SpecConstantOp.  See the
             // SPIRV spec for details.  This way we will handle IDs and literals as appropriate for
             // the embedded op.
-            if (opCode == spv::OpSpecConstantOp) {
+            if (opCode == spv::Op::OpSpecConstantOp) {
                 if (op == 0) {
                     opCode = asOpCode(word++);  // this is the opcode embedded in the SpecConstantOp.
                     --numOperands;
                 }
             }
 
-            switch (spv::InstructionDesc[opCode].operands.getClass(op)) {
+            switch (spv::InstructionDesc[enumCast(opCode)].operands.getClass(op)) {
             case spv::OperandId:
             case spv::OperandScope:
             case spv::OperandMemorySemantics:
@@ -615,7 +615,7 @@ namespace spv {
                 return nextInst;
 
             case spv::OperandVariableLiteralId: {
-                if (opCode == OpSwitch) {
+                if (opCode == Op::OpSwitch) {
                     // word-2 is the position of the selector ID.  OpSwitch Literals match its type.
                     // In case the IDs are currently being remapped, we get the word[-2] ID from
                     // the circular idBuffer.
@@ -651,8 +651,43 @@ namespace spv {
             case spv::OperandExecutionMode:
                 return nextInst;
 
+            case spv::OperandMemoryAccess:
+                {
+                    uint32_t mask = spv[word];
+                    if (mask & uint32_t(spv::MemoryAccessMask::Aligned)) {
+                        ++word;
+                        --numOperands;
+                    }
+                    if (mask & uint32_t(spv::MemoryAccessMask::MakePointerAvailable |
+                                        spv::MemoryAccessMask::MakePointerVisible)) {
+                        idFn(asId(word+1));
+                        ++word;
+                        --numOperands;
+                    }
+                    ++word;
+                }
+                break;
+
+            case spv::OperandTensorAddressingOperands:
+                {
+                    uint32_t mask = spv[word];
+                    if (mask & uint32_t(spv::TensorAddressingOperandsMask::TensorView)) {
+                        idFn(asId(word+1));
+                        ++word;
+                        --numOperands;
+                    }
+                    if (mask & uint32_t(spv::TensorAddressingOperandsMask::DecodeFunc)) {
+                        idFn(asId(word+1));
+                        ++word;
+                        --numOperands;
+                    }
+                    ++word;
+                }
+                break;
+
             // Single word operands we simply ignore, as they hold no IDs
             case spv::OperandLiteralNumber:
+            case spv::OperandOptionalLiteral:
             case spv::OperandSource:
             case spv::OperandExecutionModel:
             case spv::OperandAddressing:
@@ -675,7 +710,6 @@ namespace spv {
             case spv::OperandSelect:
             case spv::OperandLoop:
             case spv::OperandFunction:
-            case spv::OperandMemoryAccess:
             case spv::OperandGroupOperation:
             case spv::OperandKernelEnqueueFlags:
             case spv::OperandKernelProfilingInfo:
@@ -767,26 +801,26 @@ namespace spv {
             const unsigned start  = instPos[entry];
             const spv::Op  opCode = asOpCode(start);
 
-            if (opCode == spv::OpFunction)
+            if (opCode == spv::Op::OpFunction)
                 fnId   = asId(start + 2);
 
-            if (opCode == spv::OpFunctionEnd)
+            if (opCode == spv::Op::OpFunctionEnd)
                 fnId = spv::NoResult;
 
             if (fnId != spv::NoResult) { // if inside a function
-                if (spv::InstructionDesc[opCode].hasResult()) {
-                    const unsigned word    = start + (spv::InstructionDesc[opCode].hasType() ? 2 : 1);
+                if (spv::InstructionDesc[enumCast(opCode)].hasResult()) {
+                    const unsigned word    = start + (spv::InstructionDesc[enumCast(opCode)].hasType() ? 2 : 1);
                     const spv::Id  resId   = asId(word);
                     std::uint32_t  hashval = fnId * 17; // small prime
 
                     for (unsigned i = entry-1; i >= entry-windowSize; --i) {
-                        if (asOpCode(instPos[i]) == spv::OpFunction)
+                        if (asOpCode(instPos[i]) == spv::Op::OpFunction)
                             break;
                         hashval = hashval * 30103 + asOpCodeHash(instPos[i]); // 30103 = semiarbitrary prime
                     }
 
                     for (unsigned i = entry; i <= entry + windowSize; ++i) {
-                        if (asOpCode(instPos[i]) == spv::OpFunctionEnd)
+                        if (asOpCode(instPos[i]) == spv::Op::OpFunctionEnd)
                             break;
                         hashval = hashval * 30103 + asOpCodeHash(instPos[i]); // 30103 = semiarbitrary prime
                     }
@@ -801,7 +835,7 @@ namespace spv {
             }
         }
 
-        spv::Op          thisOpCode(spv::OpNop);
+        spv::Op thisOpCode(spv::Op::OpNop);
         std::unordered_map<int, int> opCounter;
         int              idCounter(0);
         fnId = spv::NoResult;
@@ -809,53 +843,53 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 switch (opCode) {
-                case spv::OpFunction:
+                case spv::Op::OpFunction:
                     // Reset counters at each function
                     idCounter = 0;
                     opCounter.clear();
                     fnId = asId(start + 2);
                     break;
 
-                case spv::OpImageSampleImplicitLod:
-                case spv::OpImageSampleExplicitLod:
-                case spv::OpImageSampleDrefImplicitLod:
-                case spv::OpImageSampleDrefExplicitLod:
-                case spv::OpImageSampleProjImplicitLod:
-                case spv::OpImageSampleProjExplicitLod:
-                case spv::OpImageSampleProjDrefImplicitLod:
-                case spv::OpImageSampleProjDrefExplicitLod:
-                case spv::OpDot:
-                case spv::OpCompositeExtract:
-                case spv::OpCompositeInsert:
-                case spv::OpVectorShuffle:
-                case spv::OpLabel:
-                case spv::OpVariable:
-
-                case spv::OpAccessChain:
-                case spv::OpLoad:
-                case spv::OpStore:
-                case spv::OpCompositeConstruct:
-                case spv::OpFunctionCall:
-                    ++opCounter[opCode];
+                case spv::Op::OpImageSampleImplicitLod:
+                case spv::Op::OpImageSampleExplicitLod:
+                case spv::Op::OpImageSampleDrefImplicitLod:
+                case spv::Op::OpImageSampleDrefExplicitLod:
+                case spv::Op::OpImageSampleProjImplicitLod:
+                case spv::Op::OpImageSampleProjExplicitLod:
+                case spv::Op::OpImageSampleProjDrefImplicitLod:
+                case spv::Op::OpImageSampleProjDrefExplicitLod:
+                case spv::Op::OpDot:
+                case spv::Op::OpCompositeExtract:
+                case spv::Op::OpCompositeInsert:
+                case spv::Op::OpVectorShuffle:
+                case spv::Op::OpLabel:
+                case spv::Op::OpVariable:
+
+                case spv::Op::OpAccessChain:
+                case spv::Op::OpLoad:
+                case spv::Op::OpStore:
+                case spv::Op::OpCompositeConstruct:
+                case spv::Op::OpFunctionCall:
+                    ++opCounter[enumCast(opCode)];
                     idCounter = 0;
                     thisOpCode = opCode;
                     break;
                 default:
-                    thisOpCode = spv::OpNop;
+                    thisOpCode = spv::Op::OpNop;
                 }
 
                 return false;
             },
 
             [&](spv::Id& id) {
-                if (thisOpCode != spv::OpNop) {
+                if (thisOpCode != spv::Op::OpNop) {
                     ++idCounter;
                     const std::uint32_t hashval =
                         // Explicitly cast operands to unsigned int to avoid integer
                         // promotion to signed int followed by integer overflow,
                         // which would result in undefined behavior.
-                        static_cast<unsigned int>(opCounter[thisOpCode])
-                        * thisOpCode
+                        static_cast<unsigned int>(opCounter[enumCast(thisOpCode)])
+                        * enumCast(thisOpCode)
                         * 50047
                         + idCounter
                         + static_cast<unsigned int>(fnId) * 117;
@@ -877,16 +911,16 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 // Add inputs and uniforms to the map
-                if ((opCode == spv::OpVariable && asWordCount(start) == 4) &&
-                    (spv[start+3] == spv::StorageClassUniform ||
-                    spv[start+3] == spv::StorageClassUniformConstant ||
-                    spv[start+3] == spv::StorageClassInput))
+                if ((opCode == spv::Op::OpVariable && asWordCount(start) == 4) &&
+                    (spv[start+3] == (unsigned)spv::StorageClass::Uniform ||
+                    spv[start+3] == (unsigned)spv::StorageClass::UniformConstant ||
+                    spv[start+3] == (unsigned)spv::StorageClass::Input))
                     fnLocalVars.insert(asId(start+2));
 
-                if (opCode == spv::OpAccessChain && fnLocalVars.count(asId(start+3)) > 0)
+                if (opCode == spv::Op::OpAccessChain && fnLocalVars.count(asId(start+3)) > 0)
                     fnLocalVars.insert(asId(start+2));
 
-                if (opCode == spv::OpLoad && fnLocalVars.count(asId(start+3)) > 0) {
+                if (opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start+3)) > 0) {
                     idMap[asId(start+2)] = asId(start+3);
                     stripInst(start);
                 }
@@ -907,11 +941,11 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 // Add inputs and uniforms to the map
-                if ((opCode == spv::OpVariable && asWordCount(start) == 4) &&
-                    (spv[start+3] == spv::StorageClassOutput))
+                if ((opCode == spv::Op::OpVariable && asWordCount(start) == 4) &&
+                    (spv[start+3] == (int)spv::StorageClass::Output))
                     fnLocalVars.insert(asId(start+2));
 
-                if (opCode == spv::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
+                if (opCode == spv::Op::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
                     idMap[asId(start+2)] = asId(start+1);
                     stripInst(start);
                 }
@@ -952,19 +986,19 @@ namespace spv {
                     ++blockNum;
 
                 // Add local variables to the map
-                if ((opCode == spv::OpVariable && spv[start+3] == spv::StorageClassFunction && asWordCount(start) == 4)) {
+                if ((opCode == spv::Op::OpVariable && spv[start+3] == (unsigned)spv::StorageClass::Function && asWordCount(start) == 4)) {
                     fnLocalVars.insert(asId(start+2));
                     return true;
                 }
 
                 // Ignore process vars referenced via access chain
-                if ((opCode == spv::OpAccessChain || opCode == spv::OpInBoundsAccessChain) && fnLocalVars.count(asId(start+3)) > 0) {
+                if ((opCode == spv::Op::OpAccessChain || opCode == spv::Op::OpInBoundsAccessChain) && fnLocalVars.count(asId(start+3)) > 0) {
                     fnLocalVars.erase(asId(start+3));
                     idMap.erase(asId(start+3));
                     return true;
                 }
 
-                if (opCode == spv::OpLoad && fnLocalVars.count(asId(start+3)) > 0) {
+                if (opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start + 3)) > 0) {
                     const spv::Id varId = asId(start+3);
 
                     // Avoid loads before stores
@@ -974,7 +1008,7 @@ namespace spv {
                     }
 
                     // don't do for volatile references
-                    if (wordCount > 4 && (spv[start+4] & spv::MemoryAccessVolatileMask)) {
+                    if (wordCount > 4 && (spv[start+4] & spv::MemoryAccessMask::Volatile)) {
                         fnLocalVars.erase(varId);
                         idMap.erase(varId);
                     }
@@ -990,7 +1024,7 @@ namespace spv {
                     return true;
                 }
 
-                if (opCode == spv::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
+                if (opCode == spv::Op::OpStore && fnLocalVars.count(asId(start+1)) > 0) {
                     const spv::Id varId = asId(start+1);
 
                     if (idMap.find(varId) == idMap.end()) {
@@ -1002,7 +1036,7 @@ namespace spv {
                     }
 
                     // don't do for volatile references
-                    if (wordCount > 3 && (spv[start+3] & spv::MemoryAccessVolatileMask)) {
+                    if (wordCount > 3 && (spv[start+3] & spv::MemoryAccessMask::Volatile)) {
                         fnLocalVars.erase(asId(start+3));
                         idMap.erase(asId(start+3));
                     }
@@ -1035,7 +1069,7 @@ namespace spv {
 
         process(
             [&](spv::Op opCode, unsigned start) {
-                if (opCode == spv::OpLoad && fnLocalVars.count(asId(start+3)) > 0)
+                if (opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start+3)) > 0)
                     idMap[asId(start+2)] = idMap[asId(start+3)];
                 return false;
             },
@@ -1061,9 +1095,9 @@ namespace spv {
         // Remove the load/store/variables for the ones we've discovered
         process(
             [&](spv::Op opCode, unsigned start) {
-                if ((opCode == spv::OpLoad  && fnLocalVars.count(asId(start+3)) > 0) ||
-                    (opCode == spv::OpStore && fnLocalVars.count(asId(start+1)) > 0) ||
-                    (opCode == spv::OpVariable && fnLocalVars.count(asId(start+2)) > 0)) {
+                if ((opCode == spv::Op::OpLoad && fnLocalVars.count(asId(start+3)) > 0) ||
+                    (opCode == spv::Op::OpStore && fnLocalVars.count(asId(start+1)) > 0) ||
+                    (opCode == spv::Op::OpVariable && fnLocalVars.count(asId(start+2)) > 0)) {
 
                     stripInst(start);
                     return true;
@@ -1142,10 +1176,10 @@ namespace spv {
         // Count function variable use
         process(
             [&](spv::Op opCode, unsigned start) {
-                if (opCode == spv::OpVariable) {
+                if (opCode == spv::Op::OpVariable) {
                     ++varUseCount[asId(start+2)];
                     return true;
-                } else if (opCode == spv::OpEntryPoint) {
+                } else if (opCode == spv::Op::OpEntryPoint) {
                     const int wordCount = asWordCount(start);
                     for (int i = 4; i < wordCount; i++) {
                         ++varUseCount[asId(start+i)];
@@ -1165,9 +1199,9 @@ namespace spv {
         process(
             [&](spv::Op opCode, unsigned start) {
                 spv::Id id = spv::NoResult;
-                if (opCode == spv::OpVariable)
+                if (opCode == spv::Op::OpVariable)
                     id = asId(start+2);
-                if (opCode == spv::OpDecorate || opCode == spv::OpName)
+                if (opCode == spv::Op::OpDecorate || opCode == spv::Op::OpName)
                     id = asId(start+1);
 
                 if (id != spv::NoResult && varUseCount[id] == 1)
@@ -1311,30 +1345,30 @@ namespace spv {
         const spv::Op  opCode      = asOpCode(typeStart);
 
         switch (opCode) {
-        case spv::OpTypeVoid:         return 0;
-        case spv::OpTypeBool:         return 1;
-        case spv::OpTypeInt:          return 3 + (spv[typeStart+3]);
-        case spv::OpTypeFloat:        return 5;
-        case spv::OpTypeVector:
+        case spv::Op::OpTypeVoid:         return 0;
+        case spv::Op::OpTypeBool:         return 1;
+        case spv::Op::OpTypeInt:          return 3 + (spv[typeStart+3]);
+        case spv::Op::OpTypeFloat:        return 5;
+        case spv::Op::OpTypeVector:
             return 6 + hashType(idPos(spv[typeStart+2])) * (spv[typeStart+3] - 1);
-        case spv::OpTypeMatrix:
+        case spv::Op::OpTypeMatrix:
             return 30 + hashType(idPos(spv[typeStart+2])) * (spv[typeStart+3] - 1);
-        case spv::OpTypeImage:
+        case spv::Op::OpTypeImage:
             return 120 + hashType(idPos(spv[typeStart+2])) +
                 spv[typeStart+3] +            // dimensionality
                 spv[typeStart+4] * 8 * 16 +   // depth
                 spv[typeStart+5] * 4 * 16 +   // arrayed
                 spv[typeStart+6] * 2 * 16 +   // multisampled
                 spv[typeStart+7] * 1 * 16;    // format
-        case spv::OpTypeSampler:
+        case spv::Op::OpTypeSampler:
             return 500;
-        case spv::OpTypeSampledImage:
+        case spv::Op::OpTypeSampledImage:
             return 502;
-        case spv::OpTypeArray:
+        case spv::Op::OpTypeArray:
             return 501 + hashType(idPos(spv[typeStart+2])) * spv[typeStart+3];
-        case spv::OpTypeRuntimeArray:
+        case spv::Op::OpTypeRuntimeArray:
             return 5000  + hashType(idPos(spv[typeStart+2]));
-        case spv::OpTypeStruct:
+        case spv::Op::OpTypeStruct:
             {
                 std::uint32_t hash = 10000;
                 for (unsigned w=2; w < wordCount; ++w)
@@ -1342,9 +1376,9 @@ namespace spv {
                 return hash;
             }
 
-        case spv::OpTypeOpaque:         return 6000 + spv[typeStart+2];
-        case spv::OpTypePointer:        return 100000  + hashType(idPos(spv[typeStart+3]));
-        case spv::OpTypeFunction:
+        case spv::Op::OpTypeOpaque:         return 6000 + spv[typeStart+2];
+        case spv::Op::OpTypePointer:        return 100000  + hashType(idPos(spv[typeStart+3]));
+        case spv::Op::OpTypeFunction:
             {
                 std::uint32_t hash = 200000;
                 for (unsigned w=2; w < wordCount; ++w)
@@ -1352,33 +1386,35 @@ namespace spv {
                 return hash;
             }
 
-        case spv::OpTypeEvent:           return 300000;
-        case spv::OpTypeDeviceEvent:     return 300001;
-        case spv::OpTypeReserveId:       return 300002;
-        case spv::OpTypeQueue:           return 300003;
-        case spv::OpTypePipe:            return 300004;
-        case spv::OpConstantTrue:        return 300007;
-        case spv::OpConstantFalse:       return 300008;
-        case spv::OpConstantComposite:
+        case spv::Op::OpTypeEvent:                      return 300000;
+        case spv::Op::OpTypeDeviceEvent:                return 300001;
+        case spv::Op::OpTypeReserveId:                  return 300002;
+        case spv::Op::OpTypeQueue:                      return 300003;
+        case spv::Op::OpTypePipe:                       return 300004;
+        case spv::Op::OpConstantTrue:                   return 300007;
+        case spv::Op::OpConstantFalse:                  return 300008;
+        case spv::Op::OpTypeRayQueryKHR:                return 300009;
+        case spv::Op::OpTypeAccelerationStructureKHR:   return 300010;
+        case spv::Op::OpConstantComposite:
             {
                 std::uint32_t hash = 300011 + hashType(idPos(spv[typeStart+1]));
                 for (unsigned w=3; w < wordCount; ++w)
                     hash += w * hashType(idPos(spv[typeStart+w]));
                 return hash;
             }
-        case spv::OpConstant:
+        case spv::Op::OpConstant:
             {
                 std::uint32_t hash = 400011 + hashType(idPos(spv[typeStart+1]));
                 for (unsigned w=3; w < wordCount; ++w)
                     hash += w * spv[typeStart+w];
                 return hash;
             }
-        case spv::OpConstantNull:
+        case spv::Op::OpConstantNull:
             {
                 std::uint32_t hash = 500009 + hashType(idPos(spv[typeStart+1]));
                 return hash;
             }
-        case spv::OpConstantSampler:
+        case spv::Op::OpConstantSampler:
             {
                 std::uint32_t hash = 600011 + hashType(idPos(spv[typeStart+1]));
                 for (unsigned w=3; w < wordCount; ++w)

+ 19 - 3
src/libraries/glslang/SPIRV/SPVRemapper.h

@@ -41,6 +41,21 @@
 #include <cstdlib>
 #include <exception>
 
+#ifdef GLSLANG_IS_SHARED_LIBRARY
+    #ifdef _WIN32
+        #ifdef GLSLANG_EXPORTING
+            #define GLSLANG_EXPORT __declspec(dllexport)
+        #else
+            #define GLSLANG_EXPORT __declspec(dllimport)
+        #endif
+    #elif __GNUC__ >= 4
+        #define GLSLANG_EXPORT __attribute__((visibility("default")))
+    #endif
+#endif // GLSLANG_IS_SHARED_LIBRARY
+#ifndef GLSLANG_EXPORT
+#define GLSLANG_EXPORT
+#endif
+
 namespace spv {
 
 class spirvbin_base_t
@@ -76,13 +91,14 @@ public:
 #include <set>
 #include <cassert>
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 namespace spv {
-const Id NoResult = 0;
+
+static inline constexpr Id NoResult = 0;
 
 // class to hold SPIR-V binary data for remapping, DCE, and debug stripping
-class spirvbin_t : public spirvbin_base_t
+class GLSLANG_EXPORT spirvbin_t : public spirvbin_base_t
 {
 public:
    spirvbin_t(int verbose = 0) : entryPoint(spv::NoResult), largestNewId(0), verbose(verbose), errorLatch(false)

文件差异内容过多而无法显示
+ 337 - 133
src/libraries/glslang/SPIRV/SpvBuilder.cpp


+ 91 - 45
src/libraries/glslang/SPIRV/SpvBuilder.h

@@ -48,20 +48,26 @@
 #define SpvBuilder_H
 
 #include "Logger.h"
-#include "spirv.hpp"
+#define SPV_ENABLE_UTILITY_CODE
+#include "spirv.hpp11"
 #include "spvIR.h"
+#include "spvUtil.h"
+
 namespace spv {
     #include "GLSL.ext.KHR.h"
+    #include "GLSL.ext.EXT.h"
     #include "NonSemanticShaderDebugInfo100.h"
 }
 
 #include <algorithm>
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <set>
 #include <sstream>
 #include <stack>
 #include <unordered_map>
+#include <unordered_set>
 #include <map>
 
 namespace spv {
@@ -73,6 +79,7 @@ typedef enum {
     Spv_1_3 = (1 << 16) | (3 << 8),
     Spv_1_4 = (1 << 16) | (4 << 8),
     Spv_1_5 = (1 << 16) | (5 << 8),
+    Spv_1_6 = (1 << 16) | (6 << 8),
 } SpvVersion;
 
 class Builder {
@@ -95,7 +102,7 @@ public:
         if (sItr != stringIds.end())
             return sItr->second;
         spv::Id strId = getUniqueId();
-        Instruction* fileString = new Instruction(strId, NoType, OpString);
+        Instruction* fileString = new Instruction(strId, NoType, Op::OpString);
         const char* file_c_str = str.c_str();
         fileString->addStringOperand(file_c_str);
         strings.push_back(std::unique_ptr<Instruction>(fileString));
@@ -107,7 +114,7 @@ public:
     spv::Id getMainFileId() const { return mainFileId; }
 
     // Initialize the main source file name
-    void setDebugSourceFile(const std::string& file)
+    void setDebugMainSourceFile(const std::string& file)
     {
         if (trackDebugInfo) {
             dirtyLineTracker = true;
@@ -201,6 +208,9 @@ public:
     Id makeIntType(int width) { return makeIntegerType(width, true); }
     Id makeUintType(int width) { return makeIntegerType(width, false); }
     Id makeFloatType(int width);
+    Id makeBFloat16Type();
+    Id makeFloatE5M2Type();
+    Id makeFloatE4M3Type();
     Id makeStructType(const std::vector<Id>& members, const char* name, bool const compilerGenerated = true);
     Id makeStructResultType(Id type0, Id type1);
     Id makeVectorType(Id component, int size);
@@ -214,6 +224,7 @@ public:
     Id makeCooperativeMatrixTypeKHR(Id component, Id scope, Id rows, Id cols, Id use);
     Id makeCooperativeMatrixTypeNV(Id component, Id scope, Id rows, Id cols);
     Id makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType);
+    Id makeCooperativeVectorTypeNV(Id componentType, Id components);
     Id makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands);
 
     // SPIR-V NonSemantic Shader DebugInfo Instructions
@@ -245,7 +256,7 @@ public:
     Id makeDebugValue(Id const debugLocalVariable, Id const value);
     Id makeDebugFunctionType(Id returnType, const std::vector<Id>& paramTypes);
     Id makeDebugFunction(Function* function, Id nameId, Id funcTypeId);
-    Id makeDebugLexicalBlock(uint32_t line);
+    Id makeDebugLexicalBlock(uint32_t line, uint32_t column);
     std::string unmangleFunctionName(std::string const& name) const;
 
     // Initialize non-semantic debug information for a function, including those of:
@@ -278,54 +289,59 @@ public:
         { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); }
     Id getResultingAccessChainType() const;
     Id getIdOperand(Id resultId, int idx) { return module.getInstruction(resultId)->getIdOperand(idx); }
+    Id getCooperativeVectorNumComponents(Id typeId) const { return module.getInstruction(typeId)->getIdOperand(1); }
 
     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 isCooperativeVector(Id resultId)const { return isCooperativeVectorType(getTypeId(resultId)); }
     bool isAggregate(Id resultId)    const { return isAggregateType(getTypeId(resultId)); }
     bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); }
+    bool isTensorView(Id resultId)const { return isTensorViewType(getTypeId(resultId)); }
 
     bool isBoolType(Id typeId)
-        { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); }
+        { return groupedTypes[enumCast(Op::OpTypeBool)].size() > 0 && typeId == groupedTypes[enumCast(Op::OpTypeBool)].back()->getResultId(); }
     bool isIntType(Id typeId)          const
-        { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; }
+        { return getTypeClass(typeId) == Op::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; }
+        { return getTypeClass(typeId) == Op::OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; }
+    bool isFloatType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeFloat; }
+    bool isPointerType(Id typeId)      const { return getTypeClass(typeId) == Op::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; }
+        { return getTypeClass(typeId) == Op::OpTypeFloat || getTypeClass(typeId) == Op::OpTypeInt ||
+          getTypeClass(typeId) == Op::OpTypeBool; }
+    bool isVectorType(Id typeId)       const { return getTypeClass(typeId) == Op::OpTypeVector; }
+    bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == Op::OpTypeMatrix; }
+    bool isStructType(Id typeId)       const { return getTypeClass(typeId) == Op::OpTypeStruct; }
+    bool isArrayType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeArray; }
     bool isCooperativeMatrixType(Id typeId)const
     {
-        return getTypeClass(typeId) == OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == OpTypeCooperativeMatrixNV;
+        return getTypeClass(typeId) == Op::OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == Op::OpTypeCooperativeMatrixNV;
     }
+    bool isTensorViewType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeTensorViewNV; }
+    bool isCooperativeVectorType(Id typeId) const { return getTypeClass(typeId) == Op::OpTypeCooperativeVectorNV; }
     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 isImageType(Id typeId)        const { return getTypeClass(typeId) == Op::OpTypeImage; }
+    bool isSamplerType(Id typeId)      const { return getTypeClass(typeId) == Op::OpTypeSampler; }
+    bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == Op::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 isConstantScalar(Id resultId) const { return getOpCode(resultId) == Op::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)); }
 
-    bool isVariableOpCode(Op opcode) const { return opcode == OpVariable; }
+    bool isVariableOpCode(Op opcode) const { return opcode == Op::OpVariable; }
     bool isVariable(Id resultId) const { return isVariableOpCode(getOpCode(resultId)); }
-    bool isGlobalStorage(Id resultId) const { return getStorageClass(resultId) != StorageClassFunction; }
+    bool isGlobalStorage(Id resultId) const { return getStorageClass(resultId) != StorageClass::Function; }
     bool isGlobalVariable(Id resultId) const { return isVariable(resultId) && isGlobalStorage(resultId); }
     // See if a resultId is valid for use as an initializer.
     bool isValidInitializer(Id resultId) const { return isConstant(resultId) || isGlobalVariable(resultId); }
@@ -333,7 +349,7 @@ public:
     int getScalarTypeWidth(Id typeId) const
     {
         Id scalarTypeId = getScalarTypeId(typeId);
-        assert(getTypeClass(scalarTypeId) == OpTypeInt || getTypeClass(scalarTypeId) == OpTypeFloat);
+        assert(getTypeClass(scalarTypeId) == Op::OpTypeInt || getTypeClass(scalarTypeId) == Op::OpTypeFloat);
         return module.getInstruction(scalarTypeId)->getImmediateOperand(0);
     }
 
@@ -370,6 +386,8 @@ public:
     // For making new constants (will return old constant if the requested one was already made).
     Id makeNullConstant(Id typeId);
     Id makeBoolConstant(bool b, bool specConstant = false);
+    Id makeIntConstant(Id typeId, unsigned value, bool specConstant);
+    Id makeInt64Constant(Id typeId, unsigned long long value, bool specConstant);
     Id makeInt8Constant(int i, bool specConstant = false)
         { return makeIntConstant(makeIntType(8),  (unsigned)i, specConstant); }
     Id makeUint8Constant(unsigned u, bool specConstant = false)
@@ -382,6 +400,14 @@ public:
         { return makeIntConstant(makeIntType(32),  (unsigned)i, specConstant); }
     Id makeUintConstant(unsigned u, bool specConstant = false)
         { return makeIntConstant(makeUintType(32),           u, specConstant); }
+    Id makeUintConstant(Scope u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
+    Id makeUintConstant(StorageClass u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
+    Id makeUintConstant(MemorySemanticsMask u, bool specConstant = false)
+        { return makeUintConstant((unsigned)u, specConstant); }
+    Id makeUintConstant(SourceLanguage u, bool specConstant = false)
+        { return makeUintConstant((unsigned)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)
@@ -389,6 +415,9 @@ public:
     Id makeFloatConstant(float f, bool specConstant = false);
     Id makeDoubleConstant(double d, bool specConstant = false);
     Id makeFloat16Constant(float f16, bool specConstant = false);
+    Id makeBFloat16Constant(float bf16, bool specConstant = false);
+    Id makeFloatE5M2Constant(float fe5m2, bool specConstant = false);
+    Id makeFloatE4M3Constant(float fe4m3, bool specConstant = false);
     Id makeFpConstant(Id type, double d, bool specConstant = false);
 
     Id importNonSemanticShaderDebugInfoInstructions();
@@ -419,8 +448,7 @@ public:
     // Also reset current last DebugScope and current source line to unknown
     void setBuildPoint(Block* bp) {
         buildPoint = bp;
-        // TODO: Technically, change of build point should set line tracker dirty. But we'll have bad line info for
-        //       branch instructions. Commenting this for now because at least this matches the old behavior.
+        dirtyLineTracker = true;
         dirtyScopeTracker = true;
     }
     Block* getBuildPoint() const { return buildPoint; }
@@ -429,6 +457,11 @@ public:
     // Optionally, additional debug info instructions may also be prepended.
     void addInstruction(std::unique_ptr<Instruction> inst);
 
+    // Append an instruction to the end of the current build point without prepending any debug instructions.
+    // This is useful for insertion of some debug info instructions themselves or some control flow instructions
+    // that are attached to its predecessor instruction.
+    void addInstructionNoDebugInfo(std::unique_ptr<Instruction> inst);
+
     // Make the entry-point function. The returned pointer is only valid
     // for the lifetime of this builder.
     Function* makeEntryPoint(const char*);
@@ -445,7 +478,7 @@ public:
     void makeReturn(bool implicit, Id retVal = 0);
 
     // Initialize state and generate instructions for new lexical scope
-    void enterLexicalBlock(uint32_t line);
+    void enterLexicalBlock(uint32_t line, uint32_t column);
 
     // Set state and generate instructions to exit current lexical scope
     void leaveLexicalBlock();
@@ -472,13 +505,13 @@ public:
     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);
+    void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
+        spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
 
     // Load from an Id and return it
     Id createLoad(Id lValue, spv::Decoration precision,
-        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
-        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
+        spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
 
     // Create an OpAccessChain instruction
     Id createAccessChain(StorageClass, Id base, const std::vector<Id>& offsets);
@@ -505,7 +538,7 @@ public:
     void createNoResultOp(Op, const std::vector<Id>& operands);
     void createNoResultOp(Op, const std::vector<IdImmediate>& operands);
     void createControlBarrier(Scope execution, Scope memory, MemorySemanticsMask);
-    void createMemoryBarrier(unsigned executionScope, unsigned memorySemantics);
+    void createMemoryBarrier(Scope executionScope, MemorySemanticsMask 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);
@@ -576,6 +609,7 @@ public:
         Id coarse;
         bool nonprivate;
         bool volatil;
+        bool nontemporal;
     };
 
     // Select the correct texture operation based on all inputs, and emit the correct instruction
@@ -603,10 +637,15 @@ public:
     // matrix constructor
     Id createMatrixConstructor(Decoration precision, const std::vector<Id>& sources, Id constructee);
 
+    // coopmat conversion
+    Id createCooperativeMatrixConversion(Id typeId, Id source);
+    Id createCooperativeMatrixReduce(Op opcode, Id typeId, Id source, unsigned int mask, Id func);
+    Id createCooperativeMatrixPerElementOp(Id typeId, const std::vector<Id>& operands);
+
     // Helper to use for building nested control flow with if-then-else.
     class If {
     public:
-        If(Id condition, unsigned int ctrl, Builder& builder);
+        If(Id condition, SelectionControlMask ctrl, Builder& builder);
         ~If() {}
 
         void makeBeginElse();
@@ -618,7 +657,7 @@ public:
 
         Builder& builder;
         Id condition;
-        unsigned int control;
+        SelectionControlMask control;
         Function* function;
         Block* headerBlock;
         Block* thenBlock;
@@ -638,11 +677,11 @@ public:
     // 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<int>& caseValues,
+    void makeSwitch(Id condition, SelectionControlMask control, int numSegments, const std::vector<int>& caseValues,
                     const std::vector<int>& valueToSegment, int defaultSegment, std::vector<Block*>& segmentBB);
 
     // Add a branch to the innermost switch's merge block.
-    void addSwitchBreak();
+    void addSwitchBreak(bool implicit);
 
     // Move to the next code segment, passing in the return argument in makeSwitch()
     void nextSwitchSegment(std::vector<Block*>& segmentBB, int segment);
@@ -739,6 +778,7 @@ public:
             unsigned shadercallcoherent : 1;
             unsigned nonprivate : 1;
             unsigned volatil : 1;
+            unsigned nontemporal : 1;
             unsigned isImage : 1;
             unsigned nonUniform : 1;
 
@@ -751,6 +791,7 @@ public:
                 shadercallcoherent = 0;
                 nonprivate = 0;
                 volatil = 0;
+                nontemporal = 0;
                 isImage = 0;
                 nonUniform = 0;
             }
@@ -764,6 +805,7 @@ public:
                 shadercallcoherent |= other.shadercallcoherent;
                 nonprivate |= other.nonprivate;
                 volatil |= other.volatil;
+                nontemporal = other.nontemporal;
                 isImage |= other.isImage;
                 nonUniform |= other.nonUniform;
                 return *this;
@@ -826,12 +868,12 @@ public:
 
     // use accessChain and swizzle to store value
     void accessChainStore(Id rvalue, Decoration nonUniform,
-        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
-        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone,
+        spv::Scope scope = spv::Scope::Max, unsigned int alignment = 0);
 
     // use accessChain and swizzle to load an r-value
     Id accessChainLoad(Decoration precision, Decoration l_nonUniform, Decoration r_nonUniform, Id ResultType,
-        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax,
+        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMask::MaskNone, spv::Scope scope = spv::Scope::Max,
             unsigned int alignment = 0);
 
     // Return whether or not the access chain can be represented in SPIR-V
@@ -864,9 +906,11 @@ public:
 
     void dump(std::vector<unsigned int>&) const;
 
-    void createBranch(Block* block);
+    // Add a branch to the target block.
+    // If set implicit, the branch instruction shouldn't have debug source location.
+    void createBranch(bool implicit, Block* block);
     void createConditionalBranch(Id condition, Block* thenBlock, Block* elseBlock);
-    void createLoopMerge(Block* mergeBlock, Block* continueBlock, unsigned int control,
+    void createLoopMerge(Block* mergeBlock, Block* continueBlock, LoopControlMask control,
         const std::vector<unsigned int>& operands);
 
     // Sets to generate opcode for specialization constants.
@@ -879,18 +923,16 @@ public:
     void setUseReplicatedComposites(bool use) { useReplicatedComposites = use; }
 
  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<Id>& comps);
+    Id findCompositeConstant(Op typeClass, Op opcode, Id typeId, const std::vector<Id>& comps, size_t numMembers);
     Id findStructConstant(Id typeId, const std::vector<Id>& comps);
     Id collapseAccessChain();
     void remapDynamicSwizzle();
     void transferAccessChainSwizzle(bool dynamic);
     void simplifyAccessChainSwizzle();
     void createAndSetNoPredecessorBlock(const char*);
-    void createSelectionMerge(Block* mergeBlock, unsigned int control);
+    void createSelectionMerge(Block* mergeBlock, SelectionControlMask control);
     void dumpSourceInstructions(std::vector<unsigned int>&) const;
     void dumpSourceInstructions(const spv::Id fileId, const std::string& text, std::vector<unsigned int>&) const;
     template <class Range> void dumpInstructions(std::vector<unsigned int>& out, const Range& instructions) const;
@@ -974,6 +1016,10 @@ public:
     // list of OpConstantNull instructions
     std::vector<Instruction*> nullConstants;
 
+    // Track which types have explicit layouts, to avoid reusing in storage classes without layout.
+    // Currently only tracks array types.
+    std::unordered_set<unsigned int> explicitlyLaidOut;
+
     // stack of switches
     std::stack<Block*> switchMerges;
 
@@ -996,6 +1042,6 @@ public:
     SpvBuildLogger* logger;
 };  // end Builder class
 
-};  // end spv namespace
+} // end spv namespace
 
 #endif // SpvBuilder_H

+ 116 - 115
src/libraries/glslang/SPIRV/SpvPostProcess.cpp

@@ -44,7 +44,8 @@
 #include <algorithm>
 
 #include "SpvBuilder.h"
-#include "spirv.hpp"
+#include "spirv.hpp11"
+#include "spvUtil.h"
 
 namespace spv {
     #include "GLSL.std.450.h"
@@ -64,137 +65,137 @@ namespace spv {
 void Builder::postProcessType(const Instruction& inst, Id typeId)
 {
     // Characterize the type being questioned
-    Id basicTypeOp = getMostBasicTypeClass(typeId);
+    Op basicTypeOp = getMostBasicTypeClass(typeId);
     int width = 0;
-    if (basicTypeOp == OpTypeFloat || basicTypeOp == OpTypeInt)
+    if (basicTypeOp == Op::OpTypeFloat || basicTypeOp == Op::OpTypeInt)
         width = getScalarTypeWidth(typeId);
 
     // Do opcode-specific checks
     switch (inst.getOpCode()) {
-    case OpLoad:
-    case OpStore:
-        if (basicTypeOp == OpTypeStruct) {
-            if (containsType(typeId, OpTypeInt, 8))
-                addCapability(CapabilityInt8);
-            if (containsType(typeId, OpTypeInt, 16))
-                addCapability(CapabilityInt16);
-            if (containsType(typeId, OpTypeFloat, 16))
-                addCapability(CapabilityFloat16);
+    case Op::OpLoad:
+    case Op::OpStore:
+        if (basicTypeOp == Op::OpTypeStruct) {
+            if (containsType(typeId, Op::OpTypeInt, 8))
+                addCapability(Capability::Int8);
+            if (containsType(typeId, Op::OpTypeInt, 16))
+                addCapability(Capability::Int16);
+            if (containsType(typeId, Op::OpTypeFloat, 16))
+                addCapability(Capability::Float16);
         } else {
             StorageClass storageClass = getStorageClass(inst.getIdOperand(0));
             if (width == 8) {
                 switch (storageClass) {
-                case StorageClassPhysicalStorageBufferEXT:
-                case StorageClassUniform:
-                case StorageClassStorageBuffer:
-                case StorageClassPushConstant:
+                case StorageClass::PhysicalStorageBufferEXT:
+                case StorageClass::Uniform:
+                case StorageClass::StorageBuffer:
+                case StorageClass::PushConstant:
                     break;
                 default:
-                    addCapability(CapabilityInt8);
+                    addCapability(Capability::Int8);
                     break;
                 }
             } else if (width == 16) {
                 switch (storageClass) {
-                case StorageClassPhysicalStorageBufferEXT:
-                case StorageClassUniform:
-                case StorageClassStorageBuffer:
-                case StorageClassPushConstant:
-                case StorageClassInput:
-                case StorageClassOutput:
+                case StorageClass::PhysicalStorageBufferEXT:
+                case StorageClass::Uniform:
+                case StorageClass::StorageBuffer:
+                case StorageClass::PushConstant:
+                case StorageClass::Input:
+                case StorageClass::Output:
                     break;
                 default:
-                    if (basicTypeOp == OpTypeInt)
-                        addCapability(CapabilityInt16);
-                    if (basicTypeOp == OpTypeFloat)
-                        addCapability(CapabilityFloat16);
+                    if (basicTypeOp == Op::OpTypeInt)
+                        addCapability(Capability::Int16);
+                    if (basicTypeOp == Op::OpTypeFloat)
+                        addCapability(Capability::Float16);
                     break;
                 }
             }
         }
         break;
-    case OpCopyObject:
+    case Op::OpCopyObject:
         break;
-    case OpFConvert:
-    case OpSConvert:
-    case OpUConvert:
+    case Op::OpFConvert:
+    case Op::OpSConvert:
+    case Op::OpUConvert:
         // Look for any 8/16-bit storage capabilities. If there are none, assume that
         // the convert instruction requires the Float16/Int8/16 capability.
-        if (containsType(typeId, OpTypeFloat, 16) || containsType(typeId, OpTypeInt, 16)) {
+        if (containsType(typeId, Op::OpTypeFloat, 16) || containsType(typeId, Op::OpTypeInt, 16)) {
             bool foundStorage = false;
             for (auto it = capabilities.begin(); it != capabilities.end(); ++it) {
                 spv::Capability cap = *it;
-                if (cap == spv::CapabilityStorageInputOutput16 ||
-                    cap == spv::CapabilityStoragePushConstant16 ||
-                    cap == spv::CapabilityStorageUniformBufferBlock16 ||
-                    cap == spv::CapabilityStorageUniform16) {
+                if (cap == spv::Capability::StorageInputOutput16 ||
+                    cap == spv::Capability::StoragePushConstant16 ||
+                    cap == spv::Capability::StorageUniformBufferBlock16 ||
+                    cap == spv::Capability::StorageUniform16) {
                     foundStorage = true;
                     break;
                 }
             }
             if (!foundStorage) {
-                if (containsType(typeId, OpTypeFloat, 16))
-                    addCapability(CapabilityFloat16);
-                if (containsType(typeId, OpTypeInt, 16))
-                    addCapability(CapabilityInt16);
+                if (containsType(typeId, Op::OpTypeFloat, 16))
+                    addCapability(Capability::Float16);
+                if (containsType(typeId, Op::OpTypeInt, 16))
+                    addCapability(Capability::Int16);
             }
         }
-        if (containsType(typeId, OpTypeInt, 8)) {
+        if (containsType(typeId, Op::OpTypeInt, 8)) {
             bool foundStorage = false;
             for (auto it = capabilities.begin(); it != capabilities.end(); ++it) {
                 spv::Capability cap = *it;
-                if (cap == spv::CapabilityStoragePushConstant8 ||
-                    cap == spv::CapabilityUniformAndStorageBuffer8BitAccess ||
-                    cap == spv::CapabilityStorageBuffer8BitAccess) {
+                if (cap == spv::Capability::StoragePushConstant8 ||
+                    cap == spv::Capability::UniformAndStorageBuffer8BitAccess ||
+                    cap == spv::Capability::StorageBuffer8BitAccess) {
                     foundStorage = true;
                     break;
                 }
             }
             if (!foundStorage) {
-                addCapability(CapabilityInt8);
+                addCapability(Capability::Int8);
             }
         }
         break;
-    case OpExtInst:
+    case Op::OpExtInst:
         switch (inst.getImmediateOperand(1)) {
         case GLSLstd450Frexp:
         case GLSLstd450FrexpStruct:
-            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, OpTypeInt, 16))
+            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, Op::OpTypeInt, 16))
                 addExtension(spv::E_SPV_AMD_gpu_shader_int16);
             break;
         case GLSLstd450InterpolateAtCentroid:
         case GLSLstd450InterpolateAtSample:
         case GLSLstd450InterpolateAtOffset:
-            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, OpTypeFloat, 16))
+            if (getSpvVersion() < spv::Spv_1_3 && containsType(typeId, Op::OpTypeFloat, 16))
                 addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
             break;
         default:
             break;
         }
         break;
-    case OpAccessChain:
-    case OpPtrAccessChain:
+    case Op::OpAccessChain:
+    case Op::OpPtrAccessChain:
         if (isPointerType(typeId))
             break;
-        if (basicTypeOp == OpTypeInt) {
+        if (basicTypeOp == Op::OpTypeInt) {
             if (width == 16)
-                addCapability(CapabilityInt16);
+                addCapability(Capability::Int16);
             else if (width == 8)
-                addCapability(CapabilityInt8);
+                addCapability(Capability::Int8);
         }
         break;
     default:
-        if (basicTypeOp == OpTypeInt) {
+        if (basicTypeOp == Op::OpTypeInt) {
             if (width == 16)
-                addCapability(CapabilityInt16);
+                addCapability(Capability::Int16);
             else if (width == 8)
-                addCapability(CapabilityInt8);
+                addCapability(Capability::Int8);
             else if (width == 64)
-                addCapability(CapabilityInt64);
-        } else if (basicTypeOp == OpTypeFloat) {
+                addCapability(Capability::Int64);
+        } else if (basicTypeOp == Op::OpTypeFloat) {
             if (width == 16)
-                addCapability(CapabilityFloat16);
+                addCapability(Capability::Float16);
             else if (width == 64)
-                addCapability(CapabilityFloat64);
+                addCapability(Capability::Float64);
         }
         break;
     }
@@ -205,41 +206,41 @@ void Builder::postProcess(Instruction& inst)
 {
     // Add capabilities based simply on the opcode.
     switch (inst.getOpCode()) {
-    case OpExtInst:
+    case Op::OpExtInst:
         switch (inst.getImmediateOperand(1)) {
         case GLSLstd450InterpolateAtCentroid:
         case GLSLstd450InterpolateAtSample:
         case GLSLstd450InterpolateAtOffset:
-            addCapability(CapabilityInterpolationFunction);
+            addCapability(Capability::InterpolationFunction);
             break;
         default:
             break;
         }
         break;
-    case OpDPdxFine:
-    case OpDPdyFine:
-    case OpFwidthFine:
-    case OpDPdxCoarse:
-    case OpDPdyCoarse:
-    case OpFwidthCoarse:
-        addCapability(CapabilityDerivativeControl);
+    case Op::OpDPdxFine:
+    case Op::OpDPdyFine:
+    case Op::OpFwidthFine:
+    case Op::OpDPdxCoarse:
+    case Op::OpDPdyCoarse:
+    case Op::OpFwidthCoarse:
+        addCapability(Capability::DerivativeControl);
         break;
 
-    case OpImageQueryLod:
-    case OpImageQuerySize:
-    case OpImageQuerySizeLod:
-    case OpImageQuerySamples:
-    case OpImageQueryLevels:
-        addCapability(CapabilityImageQuery);
+    case Op::OpImageQueryLod:
+    case Op::OpImageQuerySize:
+    case Op::OpImageQuerySizeLod:
+    case Op::OpImageQuerySamples:
+    case Op::OpImageQueryLevels:
+        addCapability(Capability::ImageQuery);
         break;
 
-    case OpGroupNonUniformPartitionNV:
+    case Op::OpGroupNonUniformPartitionNV:
         addExtension(E_SPV_NV_shader_subgroup_partitioned);
-        addCapability(CapabilityGroupNonUniformPartitionedNV);
+        addCapability(Capability::GroupNonUniformPartitionedNV);
         break;
 
-    case OpLoad:
-    case OpStore:
+    case Op::OpLoad:
+    case Op::OpStore:
         {
             // For any load/store to a PhysicalStorageBufferEXT, walk the accesschain
             // index list to compute the misalignment. The pre-existing alignment value
@@ -247,13 +248,13 @@ void Builder::postProcess(Instruction& inst)
             // the reference type and any scalar component selection in the accesschain,
             // and this function computes the rest from the SPIR-V Offset decorations.
             Instruction *accessChain = module.getInstruction(inst.getIdOperand(0));
-            if (accessChain->getOpCode() == OpAccessChain) {
+            if (accessChain->getOpCode() == Op::OpAccessChain) {
                 Instruction *base = module.getInstruction(accessChain->getIdOperand(0));
                 // Get the type of the base of the access chain. It must be a pointer type.
                 Id typeId = base->getTypeId();
                 Instruction *type = module.getInstruction(typeId);
-                assert(type->getOpCode() == OpTypePointer);
-                if (type->getImmediateOperand(0) != StorageClassPhysicalStorageBufferEXT) {
+                assert(type->getOpCode() == Op::OpTypePointer);
+                if (type->getImmediateOperand(0) != StorageClass::PhysicalStorageBufferEXT) {
                     break;
                 }
                 // Get the pointee type.
@@ -266,16 +267,16 @@ void Builder::postProcess(Instruction& inst)
                 int alignment = 0;
                 for (int i = 1; i < accessChain->getNumOperands(); ++i) {
                     Instruction *idx = module.getInstruction(accessChain->getIdOperand(i));
-                    if (type->getOpCode() == OpTypeStruct) {
-                        assert(idx->getOpCode() == OpConstant);
+                    if (type->getOpCode() == Op::OpTypeStruct) {
+                        assert(idx->getOpCode() == Op::OpConstant);
                         unsigned int c = idx->getImmediateOperand(0);
 
                         const auto function = [&](const std::unique_ptr<Instruction>& decoration) {
-                            if (decoration.get()->getOpCode() == OpMemberDecorate &&
+                            if (decoration.get()->getOpCode() == Op::OpMemberDecorate &&
                                 decoration.get()->getIdOperand(0) == typeId &&
                                 decoration.get()->getImmediateOperand(1) == c &&
-                                (decoration.get()->getImmediateOperand(2) == DecorationOffset ||
-                                 decoration.get()->getImmediateOperand(2) == DecorationMatrixStride)) {
+                                (decoration.get()->getImmediateOperand(2) == Decoration::Offset ||
+                                 decoration.get()->getImmediateOperand(2) == Decoration::MatrixStride)) {
                                 alignment |= decoration.get()->getImmediateOperand(3);
                             }
                         };
@@ -283,12 +284,12 @@ void Builder::postProcess(Instruction& inst)
                         // get the next member type
                         typeId = type->getIdOperand(c);
                         type = module.getInstruction(typeId);
-                    } else if (type->getOpCode() == OpTypeArray ||
-                               type->getOpCode() == OpTypeRuntimeArray) {
+                    } else if (type->getOpCode() == Op::OpTypeArray ||
+                               type->getOpCode() == Op::OpTypeRuntimeArray) {
                         const auto function = [&](const std::unique_ptr<Instruction>& decoration) {
-                            if (decoration.get()->getOpCode() == OpDecorate &&
+                            if (decoration.get()->getOpCode() == Op::OpDecorate &&
                                 decoration.get()->getIdOperand(0) == typeId &&
-                                decoration.get()->getImmediateOperand(1) == DecorationArrayStride) {
+                                decoration.get()->getImmediateOperand(1) == Decoration::ArrayStride) {
                                 alignment |= decoration.get()->getImmediateOperand(2);
                             }
                         };
@@ -302,12 +303,12 @@ void Builder::postProcess(Instruction& inst)
                     }
                 }
                 assert(inst.getNumOperands() >= 3);
-                unsigned int memoryAccess = inst.getImmediateOperand((inst.getOpCode() == OpStore) ? 2 : 1);
-                assert(memoryAccess & MemoryAccessAlignedMask);
+                auto const memoryAccess = (MemoryAccessMask)inst.getImmediateOperand((inst.getOpCode() == Op::OpStore) ? 2 : 1);
+                assert(anySet(memoryAccess, MemoryAccessMask::Aligned));
                 static_cast<void>(memoryAccess);
                 // Compute the index of the alignment operand.
                 int alignmentIdx = 2;
-                if (inst.getOpCode() == OpStore)
+                if (inst.getOpCode() == Op::OpStore)
                     alignmentIdx++;
                 // Merge new and old (mis)alignment
                 alignment |= inst.getImmediateOperand(alignmentIdx);
@@ -404,17 +405,17 @@ void Builder::postProcessFeatures() {
     // Look for any 8/16 bit type in physical storage buffer class, and set the
     // appropriate capability. This happens in createSpvVariable for other storage
     // classes, but there isn't always a variable for physical storage buffer.
-    for (int t = 0; t < (int)groupedTypes[OpTypePointer].size(); ++t) {
-        Instruction* type = groupedTypes[OpTypePointer][t];
-        if (type->getImmediateOperand(0) == (unsigned)StorageClassPhysicalStorageBufferEXT) {
-            if (containsType(type->getIdOperand(1), OpTypeInt, 8)) {
+    for (int t = 0; t < (int)groupedTypes[enumCast(Op::OpTypePointer)].size(); ++t) {
+        Instruction* type = groupedTypes[enumCast(Op::OpTypePointer)][t];
+        if (type->getImmediateOperand(0) == (unsigned)StorageClass::PhysicalStorageBufferEXT) {
+            if (containsType(type->getIdOperand(1), Op::OpTypeInt, 8)) {
                 addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
-                addCapability(spv::CapabilityStorageBuffer8BitAccess);
+                addCapability(spv::Capability::StorageBuffer8BitAccess);
             }
-            if (containsType(type->getIdOperand(1), OpTypeInt, 16) ||
-                containsType(type->getIdOperand(1), OpTypeFloat, 16)) {
+            if (containsType(type->getIdOperand(1), Op::OpTypeInt, 16) ||
+                containsType(type->getIdOperand(1), Op::OpTypeFloat, 16)) {
                 addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
-                addCapability(spv::CapabilityStorageBuffer16BitAccess);
+                addCapability(spv::Capability::StorageBuffer16BitAccess);
             }
         }
     }
@@ -437,15 +438,15 @@ void Builder::postProcessFeatures() {
                     bool foundDecoration = false;
                     const auto function = [&](const std::unique_ptr<Instruction>& decoration) {
                         if (decoration.get()->getIdOperand(0) == resultId &&
-                            decoration.get()->getOpCode() == OpDecorate &&
-                            (decoration.get()->getImmediateOperand(1) == spv::DecorationAliasedPointerEXT ||
-                             decoration.get()->getImmediateOperand(1) == spv::DecorationRestrictPointerEXT)) {
+                            decoration.get()->getOpCode() == Op::OpDecorate &&
+                            (decoration.get()->getImmediateOperand(1) == spv::Decoration::AliasedPointerEXT ||
+                             decoration.get()->getImmediateOperand(1) == spv::Decoration::RestrictPointerEXT)) {
                             foundDecoration = true;
                         }
                     };
                     std::for_each(decorations.begin(), decorations.end(), function);
                     if (!foundDecoration) {
-                        addDecoration(resultId, spv::DecorationAliasedPointerEXT);
+                        addDecoration(resultId, spv::Decoration::AliasedPointerEXT);
                     }
                 }
             }
@@ -454,13 +455,13 @@ void Builder::postProcessFeatures() {
 
     // If any Vulkan memory model-specific functionality is used, update the
     // OpMemoryModel to match.
-    if (capabilities.find(spv::CapabilityVulkanMemoryModelKHR) != capabilities.end()) {
-        memoryModel = spv::MemoryModelVulkanKHR;
+    if (capabilities.find(spv::Capability::VulkanMemoryModelKHR) != capabilities.end()) {
+        memoryModel = spv::MemoryModel::VulkanKHR;
         addIncorporatedExtension(spv::E_SPV_KHR_vulkan_memory_model, spv::Spv_1_5);
     }
 
     // Add Aliased decoration if there's more than one Workgroup Block variable.
-    if (capabilities.find(spv::CapabilityWorkgroupMemoryExplicitLayoutKHR) != capabilities.end()) {
+    if (capabilities.find(spv::Capability::WorkgroupMemoryExplicitLayoutKHR) != capabilities.end()) {
         assert(entryPoints.size() == 1);
         auto &ep = entryPoints[0];
 
@@ -471,16 +472,16 @@ void Builder::postProcessFeatures() {
 
             const Id id = ep->getIdOperand(i);
             const Instruction *instr = module.getInstruction(id);
-            if (instr->getOpCode() != spv::OpVariable)
+            if (instr->getOpCode() != spv::Op::OpVariable)
                 continue;
 
-            if (instr->getImmediateOperand(0) == spv::StorageClassWorkgroup)
+            if (instr->getImmediateOperand(0) == spv::StorageClass::Workgroup)
                 workgroup_variables.push_back(id);
         }
 
         if (workgroup_variables.size() > 1) {
             for (size_t i = 0; i < workgroup_variables.size(); i++)
-                addDecoration(workgroup_variables[i], spv::DecorationAliased);
+                addDecoration(workgroup_variables[i], spv::Decoration::Aliased);
         }
     }
 }
@@ -497,7 +498,7 @@ void Builder::postProcessSamplers()
     for (auto f: module.getFunctions()) {
 	for (auto b: f->getBlocks()) {
 	    for (auto &i: b->getInstructions()) {
-		if (i->getOpCode() == spv::OpSampledImage) {
+        if (i->getOpCode() == spv::Op::OpSampledImage) {
 		    sampledImageInstrs[i->getResultId()] = i.get();
 		}
 	    }
@@ -518,7 +519,7 @@ void Builder::postProcessSamplers()
                         if (i->getBlock() != opSampImg->getBlock()) {
                             Instruction *newInstr = new Instruction(getUniqueId(),
                                                                     opSampImg->getTypeId(),
-                                                                    spv::OpSampledImage);
+                                                                    spv::Op::OpSampledImage);
                             newInstr->addIdOperand(opSampImg->getIdOperand(0));
                             newInstr->addIdOperand(opSampImg->getIdOperand(1));
                             newInstr->setBlock(b);
@@ -548,4 +549,4 @@ void Builder::postProcess(bool compileOnly)
     postProcessSamplers();
 }
 
-}; // end spv namespace
+} // end spv namespace

+ 9 - 1
src/libraries/glslang/SPIRV/SpvTools.cpp

@@ -71,6 +71,8 @@ spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLog
         return spv_target_env::SPV_ENV_VULKAN_1_2;
     case glslang::EShTargetVulkan_1_3:
         return spv_target_env::SPV_ENV_VULKAN_1_3;
+    case glslang::EShTargetVulkan_1_4:
+        return spv_target_env::SPV_ENV_VULKAN_1_4;
     default:
         break;
     }
@@ -82,6 +84,11 @@ spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLog
     return spv_target_env::SPV_ENV_UNIVERSAL_1_0;
 }
 
+spv_target_env MapToSpirvToolsEnv(const glslang::TIntermediate& intermediate, spv::SpvBuildLogger* logger)
+{
+    return MapToSpirvToolsEnv(intermediate.getSpv(), logger);
+}
+
 // Callback passed to spvtools::Optimizer::SetMessageConsumer
 void OptimizerMesssageConsumer(spv_message_level_t level, const char *source,
         const spv_position_t &position, const char *message)
@@ -158,6 +165,7 @@ void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<
     spvValidatorOptionsSetBeforeHlslLegalization(options, prelegalization);
     spvValidatorOptionsSetScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
     spvValidatorOptionsSetWorkgroupScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
+    spvValidatorOptionsSetAllowOffsetTextureOperand(options, intermediate.usingTextureOffsetNonConst());
     spvValidateWithOptions(context, options, &binary, &diagnostic);
 
     // report
@@ -304,6 +312,6 @@ void SpirvToolsStripDebugInfo(const glslang::TIntermediate& intermediate,
     optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
 }
 
-}; // end namespace glslang
+} // end namespace glslang
 
 #endif

+ 22 - 18
src/libraries/glslang/SPIRV/SpvTools.h

@@ -49,6 +49,7 @@
 #endif
 
 #include "../glslang/MachineIndependent/Versions.h"
+#include "../glslang/Include/visibility.h"
 #include "GlslangToSpv.h"
 #include "Logger.h"
 
@@ -59,44 +60,47 @@ namespace glslang {
 class TIntermediate;
 
 // Translate glslang's view of target versioning to what SPIRV-Tools uses.
-spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger);
+GLSLANG_EXPORT spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger);
+GLSLANG_EXPORT spv_target_env MapToSpirvToolsEnv(const glslang::TIntermediate& intermediate, spv::SpvBuildLogger* logger);
 
 // Use the SPIRV-Tools disassembler to print SPIR-V using a SPV_ENV_UNIVERSAL_1_3 environment.
-void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv);
+GLSLANG_EXPORT void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv);
 
 // Use the SPIRV-Tools disassembler to print SPIR-V with a provided SPIR-V environment.
-void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv,
-                           spv_target_env requested_context);
+GLSLANG_EXPORT void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv,
+                                          spv_target_env requested_context);
 
 // Apply the SPIRV-Tools validator to generated SPIR-V.
-void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                        spv::SpvBuildLogger*, bool prelegalization);
+GLSLANG_EXPORT void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                       spv::SpvBuildLogger*, bool prelegalization);
 
 // Apply the SPIRV-Tools optimizer to generated SPIR-V.  HLSL SPIR-V is legalized in the process.
-void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                         spv::SpvBuildLogger*, const SpvOptions*);
+GLSLANG_EXPORT void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
+                                        spv::SpvBuildLogger*, const SpvOptions*);
 
 // Apply the SPIRV-Tools EliminateDeadInputComponents pass to generated SPIR-V. Put result in |spirv|.
-void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
-                                            spv::SpvBuildLogger*);
+GLSLANG_EXPORT void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                                           spv::SpvBuildLogger*);
 
 // Apply the SPIRV-Tools AnalyzeDeadOutputStores pass to generated SPIR-V. Put result in |live_locs|.
 // Return true if the result is valid.
-bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
-                                       std::unordered_set<uint32_t>* live_locs,
-                                       std::unordered_set<uint32_t>* live_builtins, spv::SpvBuildLogger*);
+GLSLANG_EXPORT bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                                      std::unordered_set<uint32_t>* live_locs,
+                                                      std::unordered_set<uint32_t>* live_builtins,
+                                                      spv::SpvBuildLogger*);
 
 // Apply the SPIRV-Tools EliminateDeadOutputStores and AggressiveDeadCodeElimination passes to generated SPIR-V using
 // |live_locs|. Put result in |spirv|.
-void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
-                                         std::unordered_set<uint32_t>* live_locs,
-                                         std::unordered_set<uint32_t>* live_builtins, spv::SpvBuildLogger*);
+GLSLANG_EXPORT void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+                                                        std::unordered_set<uint32_t>* live_locs,
+                                                        std::unordered_set<uint32_t>* live_builtins,
+                                                        spv::SpvBuildLogger*);
 
 // Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V.  This is implicitly done by
 // SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
 // optimization is disabled.
-void SpirvToolsStripDebugInfo(const glslang::TIntermediate& intermediate,
-        std::vector<unsigned int>& spirv, spv::SpvBuildLogger*);
+GLSLANG_EXPORT void SpirvToolsStripDebugInfo(const glslang::TIntermediate& intermediate,
+                                             std::vector<unsigned int>& spirv, spv::SpvBuildLogger*);
 
 #endif
 

+ 126 - 66
src/libraries/glslang/SPIRV/disassemble.cpp

@@ -36,6 +36,7 @@
 // Disassembler for SPIR-V.
 //
 
+#include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <cassert>
@@ -47,6 +48,7 @@
 
 #include "disassemble.h"
 #include "doc.h"
+#include "spvUtil.h"
 
 namespace spv {
     extern "C" {
@@ -96,7 +98,7 @@ public:
 protected:
     SpirvStream(const SpirvStream&);
     SpirvStream& operator=(const SpirvStream&);
-    Op getOpCode(int id) const { return idInstruction[id] ? (Op)(stream[idInstruction[id]] & OpCodeMask) : OpNop; }
+    Op getOpCode(int id) const { return idInstruction[id] ? (Op)(stream[idInstruction[id]] & OpCodeMask) : Op::OpNop; }
 
     // Output methods
     void outputIndent();
@@ -186,14 +188,14 @@ void SpirvStream::processInstructions()
 
         // Type <id>
         Id typeId = 0;
-        if (InstructionDesc[opCode].hasType()) {
+        if (InstructionDesc[enumCast(opCode)].hasType()) {
             typeId = stream[word++];
             --numOperands;
         }
 
         // Result <id>
         Id resultId = 0;
-        if (InstructionDesc[opCode].hasResult()) {
+        if (InstructionDesc[enumCast(opCode)].hasResult()) {
             resultId = stream[word++];
             --numOperands;
 
@@ -338,26 +340,38 @@ int SpirvStream::disassembleString()
     return decoderes.first;
 }
 
+static uint32_t popcount(uint32_t mask)
+{
+    uint32_t count = 0;
+    while (mask) {
+        if (mask & 1) {
+            count++;
+        }
+        mask >>= 1;
+    }
+    return count;
+}
+
 void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, int numOperands)
 {
     // Process the opcode
 
-    out << (OpcodeString(opCode) + 2);  // leave out the "Op"
+    out << (OpcodeString((int)opCode) + 2);  // leave out the "Op"
 
-    if (opCode == OpLoopMerge || opCode == OpSelectionMerge)
+    if (opCode == Op::OpLoopMerge || opCode == Op::OpSelectionMerge)
         nextNestedControl = stream[word];
-    else if (opCode == OpBranchConditional || opCode == OpSwitch) {
+    else if (opCode == Op::OpBranchConditional || opCode == Op::OpSwitch) {
         if (nextNestedControl) {
             nestedControl.push(nextNestedControl);
             nextNestedControl = 0;
         }
-    } else if (opCode == OpExtInstImport) {
+    } else if (opCode == Op::OpExtInstImport) {
         idDescriptor[resultId] = decodeString().second;
     }
     else {
         if (resultId != 0 && idDescriptor[resultId].size() == 0) {
             switch (opCode) {
-            case OpTypeInt:
+            case Op::OpTypeInt:
                 switch (stream[word]) {
                 case 8:  idDescriptor[resultId] = "int8_t"; break;
                 case 16: idDescriptor[resultId] = "int16_t"; break;
@@ -366,26 +380,49 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                 case 64: idDescriptor[resultId] = "int64_t"; break;
                 }
                 break;
-            case OpTypeFloat:
+            case Op::OpTypeFloat:
                 switch (stream[word]) {
-                case 16: idDescriptor[resultId] = "float16_t"; break;
+                case 8:
+                case 16:
+                    if (numOperands > 1) {
+                        switch (stream[word+1]) {
+                        default:
+                            assert(0); [[fallthrough]];
+                        case (int)spv::FPEncoding::BFloat16KHR:
+                            idDescriptor[resultId] = "bfloat16_t";
+                            break;
+                        case (int)spv::FPEncoding::Float8E4M3EXT:
+                            idDescriptor[resultId] = "floate4m3_t";
+                            break;
+                        case (int)spv::FPEncoding::Float8E5M2EXT:
+                            idDescriptor[resultId] = "floate5m2_t";
+                            break;
+                        }
+                    } else {
+                        idDescriptor[resultId] = "float16_t";
+                    }
+                    break;
                 default: assert(0); [[fallthrough]];
                 case 32: idDescriptor[resultId] = "float"; break;
                 case 64: idDescriptor[resultId] = "float64_t"; break;
                 }
                 break;
-            case OpTypeBool:
+            case Op::OpTypeBool:
                 idDescriptor[resultId] = "bool";
                 break;
-            case OpTypeStruct:
+            case Op::OpTypeStruct:
                 idDescriptor[resultId] = "struct";
                 break;
-            case OpTypePointer:
+            case Op::OpTypePointer:
                 idDescriptor[resultId] = "ptr";
                 break;
-            case OpTypeVector:
+            case Op::OpTypeVector:
                 if (idDescriptor[stream[word]].size() > 0) {
-                    idDescriptor[resultId].append(idDescriptor[stream[word]].begin(), idDescriptor[stream[word]].begin() + 1);
+                    if (idDescriptor[stream[word]].substr(0,2) == "bf") {
+                        idDescriptor[resultId].append(idDescriptor[stream[word]].begin(), idDescriptor[stream[word]].begin() + 2);
+                    } else {
+                        idDescriptor[resultId].append(idDescriptor[stream[word]].begin(), idDescriptor[stream[word]].begin() + 1);
+                    }
                     if (strstr(idDescriptor[stream[word]].c_str(), "8")) {
                         idDescriptor[resultId].append("8");
                     }
@@ -417,10 +454,10 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
     // swapped in mid-traversal.
 
     // Handle images specially, so can put out helpful strings.
-    if (opCode == OpTypeImage) {
+    if (opCode == Op::OpTypeImage) {
         out << " ";
         disassembleIds(1);
-        out << " " << DimensionString((Dim)stream[word++]);
+        out << " " << DimensionString((int)(Dim)stream[word++]);
         out << (stream[word++] != 0 ? " depth" : "");
         out << (stream[word++] != 0 ? " array" : "");
         out << (stream[word++] != 0 ? " multi-sampled" : "");
@@ -429,7 +466,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
         case 1: out << " sampled";    break;
         case 2: out << " nonsampled"; break;
         }
-        out << " format:" << ImageFormatString((ImageFormat)stream[word++]);
+        out << " format:" << ImageFormatString((int)(ImageFormat)stream[word++]);
 
         if (numOperands == 8) {
             out << " " << AccessQualifierString(stream[word++]);
@@ -438,9 +475,9 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
     }
 
     // Handle all the parameterized operands
-    for (int op = 0; op < InstructionDesc[opCode].operands.getNum() && numOperands > 0; ++op) {
+    for (int op = 0; op < InstructionDesc[enumCast(opCode)].operands.getNum() && numOperands > 0; ++op) {
         out << " ";
-        OperandClass operandClass = InstructionDesc[opCode].operands.getClass(op);
+        OperandClass operandClass = InstructionDesc[enumCast(opCode)].operands.getClass(op);
         switch (operandClass) {
         case OperandId:
         case OperandScope:
@@ -448,7 +485,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
             disassembleIds(1);
             --numOperands;
             // Get names for printing "(XXX)" for readability, *after* this id
-            if (opCode == OpName)
+            if (opCode == Op::OpName)
                 idDescriptor[stream[word - 1]] = decodeString().second;
             break;
         case OperandVariableIds:
@@ -461,8 +498,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
             return;
         case OperandOptionalLiteral:
         case OperandVariableLiterals:
-            if ((opCode == OpDecorate && stream[word - 1] == DecorationBuiltIn) ||
-                (opCode == OpMemberDecorate && stream[word - 1] == DecorationBuiltIn)) {
+            if ((opCode == Op::OpDecorate && stream[word - 1] == Decoration::BuiltIn) ||
+                (opCode == Op::OpMemberDecorate && stream[word - 1] == Decoration::BuiltIn)) {
                 out << BuiltInString(stream[word++]);
                 --numOperands;
                 ++op;
@@ -498,7 +535,7 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
         case OperandLiteralNumber:
             disassembleImmediates(1);
             --numOperands;
-            if (opCode == OpExtInst) {
+            if (opCode == Op::OpExtInst) {
                 ExtInstSet extInstSet = GLSL450Inst;
                 const char* name = idDescriptor[stream[word - 2]].c_str();
                 if (strcmp("OpenCL.std", name) == 0) {
@@ -552,18 +589,41 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                 numOperands -= disassembleString();
             return;
         case OperandMemoryAccess:
-            outputMask(OperandMemoryAccess, stream[word++]);
-            --numOperands;
-            // Aligned is the only memory access operand that uses an immediate
-            // value, and it is also the first operand that uses a value at all.
-            if (stream[word-1] & MemoryAccessAlignedMask) {
-                disassembleImmediates(1);
-                numOperands--;
-                if (numOperands)
+            {
+                outputMask(OperandMemoryAccess, stream[word++]);
+                --numOperands;
+                // Put a space after "None" if there are any remaining operands
+                if (numOperands && stream[word-1] == 0) {
                     out << " ";
+                }
+                uint32_t mask = stream[word-1];
+                // Aligned is the only memory access operand that uses an immediate
+                // value, and it is also the first operand that uses a value at all.
+                if (mask & (uint32_t)MemoryAccessMask::Aligned) {
+                    disassembleImmediates(1);
+                    numOperands--;
+                    if (numOperands)
+                        out << " ";
+                }
+
+                uint32_t bitCount = popcount(mask & (uint32_t)(MemoryAccessMask::MakePointerAvailable | MemoryAccessMask::MakePointerVisible));
+                disassembleIds(bitCount);
+                numOperands -= bitCount;
             }
-            disassembleIds(numOperands);
-            return;
+            break;
+        case OperandTensorAddressingOperands:
+            {
+                outputMask(OperandTensorAddressingOperands, stream[word++]);
+                --numOperands;
+                // Put a space after "None" if there are any remaining operands
+                if (numOperands && stream[word-1] == 0) {
+                    out << " ";
+                }
+                uint32_t bitCount = popcount(stream[word-1]);
+                disassembleIds(bitCount);
+                numOperands -= bitCount;
+            }
+            break;
         default:
             assert(operandClass >= OperandSource && operandClass < OperandOpcode);
 
@@ -721,41 +781,41 @@ static const char* GLSLextNVGetDebugNames(const char* name, unsigned entrypoint)
         strcmp(name, spv::E_SPV_NV_shader_image_footprint) == 0) {
         switch (entrypoint) {
         // NV builtins
-        case BuiltInViewportMaskNV:                 return "ViewportMaskNV";
-        case BuiltInSecondaryPositionNV:            return "SecondaryPositionNV";
-        case BuiltInSecondaryViewportMaskNV:        return "SecondaryViewportMaskNV";
-        case BuiltInPositionPerViewNV:              return "PositionPerViewNV";
-        case BuiltInViewportMaskPerViewNV:          return "ViewportMaskPerViewNV";
-        case BuiltInBaryCoordNV:                    return "BaryCoordNV";
-        case BuiltInBaryCoordNoPerspNV:             return "BaryCoordNoPerspNV";
-        case BuiltInTaskCountNV:                    return "TaskCountNV";
-        case BuiltInPrimitiveCountNV:               return "PrimitiveCountNV";
-        case BuiltInPrimitiveIndicesNV:             return "PrimitiveIndicesNV";
-        case BuiltInClipDistancePerViewNV:          return "ClipDistancePerViewNV";
-        case BuiltInCullDistancePerViewNV:          return "CullDistancePerViewNV";
-        case BuiltInLayerPerViewNV:                 return "LayerPerViewNV";
-        case BuiltInMeshViewCountNV:                return "MeshViewCountNV";
-        case BuiltInMeshViewIndicesNV:              return "MeshViewIndicesNV";
+        case (unsigned)BuiltIn::ViewportMaskNV:                 return "ViewportMaskNV";
+        case (unsigned)BuiltIn::SecondaryPositionNV:            return "SecondaryPositionNV";
+        case (unsigned)BuiltIn::SecondaryViewportMaskNV:        return "SecondaryViewportMaskNV";
+        case (unsigned)BuiltIn::PositionPerViewNV:              return "PositionPerViewNV";
+        case (unsigned)BuiltIn::ViewportMaskPerViewNV:          return "ViewportMaskPerViewNV";
+        case (unsigned)BuiltIn::BaryCoordNV:                    return "BaryCoordNV";
+        case (unsigned)BuiltIn::BaryCoordNoPerspNV:             return "BaryCoordNoPerspNV";
+        case (unsigned)BuiltIn::TaskCountNV:                    return "TaskCountNV";
+        case (unsigned)BuiltIn::PrimitiveCountNV:               return "PrimitiveCountNV";
+        case (unsigned)BuiltIn::PrimitiveIndicesNV:             return "PrimitiveIndicesNV";
+        case (unsigned)BuiltIn::ClipDistancePerViewNV:          return "ClipDistancePerViewNV";
+        case (unsigned)BuiltIn::CullDistancePerViewNV:          return "CullDistancePerViewNV";
+        case (unsigned)BuiltIn::LayerPerViewNV:                 return "LayerPerViewNV";
+        case (unsigned)BuiltIn::MeshViewCountNV:                return "MeshViewCountNV";
+        case (unsigned)BuiltIn::MeshViewIndicesNV:              return "MeshViewIndicesNV";
 
         // NV Capabilities
-        case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
-        case CapabilityShaderViewportMaskNV:        return "ShaderViewportMaskNV";
-        case CapabilityShaderStereoViewNV:          return "ShaderStereoViewNV";
-        case CapabilityPerViewAttributesNV:         return "PerViewAttributesNV";
-        case CapabilityFragmentBarycentricNV:       return "FragmentBarycentricNV";
-        case CapabilityMeshShadingNV:               return "MeshShadingNV";
-        case CapabilityImageFootprintNV:            return "ImageFootprintNV";
-        case CapabilitySampleMaskOverrideCoverageNV:return "SampleMaskOverrideCoverageNV";
+        case (unsigned)Capability::GeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
+        case (unsigned)Capability::ShaderViewportMaskNV:        return "ShaderViewportMaskNV";
+        case (unsigned)Capability::ShaderStereoViewNV:          return "ShaderStereoViewNV";
+        case (unsigned)Capability::PerViewAttributesNV:         return "PerViewAttributesNV";
+        case (unsigned)Capability::FragmentBarycentricNV:       return "FragmentBarycentricNV";
+        case (unsigned)Capability::MeshShadingNV:               return "MeshShadingNV";
+        case (unsigned)Capability::ImageFootprintNV:            return "ImageFootprintNV";
+        case (unsigned)Capability::SampleMaskOverrideCoverageNV:return "SampleMaskOverrideCoverageNV";
 
         // NV Decorations
-        case DecorationOverrideCoverageNV:          return "OverrideCoverageNV";
-        case DecorationPassthroughNV:               return "PassthroughNV";
-        case DecorationViewportRelativeNV:          return "ViewportRelativeNV";
-        case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
-        case DecorationPerVertexNV:                 return "PerVertexNV";
-        case DecorationPerPrimitiveNV:              return "PerPrimitiveNV";
-        case DecorationPerViewNV:                   return "PerViewNV";
-        case DecorationPerTaskNV:                   return "PerTaskNV";
+        case (unsigned)Decoration::OverrideCoverageNV:          return "OverrideCoverageNV";
+        case (unsigned)Decoration::PassthroughNV:               return "PassthroughNV";
+        case (unsigned)Decoration::ViewportRelativeNV:          return "ViewportRelativeNV";
+        case (unsigned)Decoration::SecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
+        case (unsigned)Decoration::PerVertexNV:                 return "PerVertexNV";
+        case (unsigned)Decoration::PerPrimitiveNV:              return "PerPrimitiveNV";
+        case (unsigned)Decoration::PerViewNV:                   return "PerViewNV";
+        case (unsigned)Decoration::PerTaskNV:                   return "PerTaskNV";
 
         default:                                    return "Bad";
         }
@@ -825,4 +885,4 @@ void Disassemble(std::ostream& out, const std::vector<unsigned int>& stream)
     SpirvStream.processInstructions();
 }
 
-}; // end namespace spv
+} // end namespace spv

+ 3 - 1
src/libraries/glslang/SPIRV/disassemble.h

@@ -43,10 +43,12 @@
 #include <iostream>
 #include <vector>
 
+#include "../glslang/Include/visibility.h"
+
 namespace spv {
 
     // disassemble with glslang custom disassembler
-    void Disassemble(std::ostream& out, const std::vector<unsigned int>&);
+    GLSLANG_EXPORT void Disassemble(std::ostream& out, const std::vector<unsigned int>&);
 
 }  // end namespace spv
 

文件差异内容过多而无法显示
+ 566 - 454
src/libraries/glslang/SPIRV/doc.cpp


+ 2 - 1
src/libraries/glslang/SPIRV/doc.h

@@ -38,7 +38,7 @@
 
 #pragma once
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 #include <vector>
 
@@ -157,6 +157,7 @@ enum OperandClass {
     OperandKernelProfilingInfo,
     OperandCapability,
     OperandCooperativeMatrixOperands,
+    OperandTensorAddressingOperands,
 
     OperandOpcode,
 

+ 94 - 0
src/libraries/glslang/SPIRV/hex_float.h

@@ -50,6 +50,52 @@ class Float16 {
   uint16_t val;
 };
 
+class FloatE5M2 {
+ public:
+  FloatE5M2(uint8_t v) : val(v) {}
+  FloatE5M2() {}
+  static bool isNan(const FloatE5M2& val) {
+    return ((val.val & 0x7C) == 0x7C) && ((val.val & 0x3) != 0);
+  }
+  // Returns true if the given value is any kind of infinity.
+  static bool isInfinity(const FloatE5M2& val) {
+    return ((val.val & 0x7C) == 0x7C) && ((val.val & 0x3) == 0);
+  }
+  FloatE5M2(const FloatE5M2& other) { val = other.val; }
+  uint8_t get_value() const { return val; }
+
+  // Returns the maximum normal value.
+  static FloatE5M2 max() { return FloatE5M2(0x7B); }
+  // Returns the lowest normal value.
+  static FloatE5M2 lowest() { return FloatE5M2(0xFB); }
+
+ private:
+  uint8_t val;
+};
+
+class FloatE4M3 {
+ public:
+  FloatE4M3(uint8_t v) : val(v) {}
+  FloatE4M3() {}
+  static bool isNan(const FloatE4M3& val) {
+    return (val.val & 0x7F) == 0x7F;
+  }
+  // Returns true if the given value is any kind of infinity.
+  static bool isInfinity(const FloatE4M3&) {
+    return false;
+  }
+  FloatE4M3(const FloatE4M3& other) { val = other.val; }
+  uint8_t get_value() const { return val; }
+
+  // Returns the maximum normal value.
+  static FloatE4M3 max() { return FloatE4M3(0x7E); }
+  // Returns the lowest normal value.
+  static FloatE4M3 lowest() { return FloatE4M3(0xFE); }
+
+ private:
+  uint8_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
@@ -95,6 +141,30 @@ struct FloatProxyTraits<Float16> {
   static Float16 lowest() { return Float16::lowest(); }
 };
 
+template <>
+struct FloatProxyTraits<FloatE5M2> {
+  typedef uint8_t uint_type;
+  static bool isNan(FloatE5M2 f) { return FloatE5M2::isNan(f); }
+  // Returns true if the given value is any kind of infinity.
+  static bool isInfinity(FloatE5M2 f) { return FloatE5M2::isInfinity(f); }
+  // Returns the maximum normal value.
+  static FloatE5M2 max() { return FloatE5M2::max(); }
+  // Returns the lowest normal value.
+  static FloatE5M2 lowest() { return FloatE5M2::lowest(); }
+};
+
+template <>
+struct FloatProxyTraits<FloatE4M3> {
+  typedef uint8_t uint_type;
+  static bool isNan(FloatE4M3 f) { return FloatE4M3::isNan(f); }
+  // Returns true if the given value is any kind of infinity.
+  static bool isInfinity(FloatE4M3 f) { return FloatE4M3::isInfinity(f); }
+  // Returns the maximum normal value.
+  static FloatE4M3 max() { return FloatE4M3::max(); }
+  // Returns the lowest normal value.
+  static FloatE4M3 lowest() { return FloatE4M3::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.
@@ -226,6 +296,30 @@ struct HexFloatTraits<FloatProxy<Float16>> {
   static const uint_type exponent_bias = 15;
 };
 
+template <>
+struct HexFloatTraits<FloatProxy<FloatE5M2>> {
+  typedef uint8_t uint_type;
+  typedef int8_t int_type;
+  typedef uint8_t underlying_type;
+  typedef uint8_t native_type;
+  static const uint_type num_used_bits = 8;
+  static const uint_type num_exponent_bits = 5;
+  static const uint_type num_fraction_bits = 2;
+  static const uint_type exponent_bias = 15;
+};
+
+template <>
+struct HexFloatTraits<FloatProxy<FloatE4M3>> {
+  typedef uint8_t uint_type;
+  typedef int8_t int_type;
+  typedef uint8_t underlying_type;
+  typedef uint8_t native_type;
+  static const uint_type num_used_bits = 8;
+  static const uint_type num_exponent_bits = 4;
+  static const uint_type num_fraction_bits = 3;
+  static const uint_type exponent_bias = 7;
+};
+
 enum round_direction {
   kRoundToZero,
   kRoundToNearestEven,

+ 0 - 2827
src/libraries/glslang/SPIRV/spirv.hpp

@@ -1,2827 +0,0 @@
-// Copyright (c) 2014-2024 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, Beef
-//
-// - 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
-// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
-//     e.g.: Spv.Specification.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 0x10600
-#define SPV_REVISION 1
-
-static const unsigned int MagicNumber = 0x07230203;
-static const unsigned int Version = 0x00010600;
-static const unsigned int Revision = 1;
-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,
-    SourceLanguageCPP_for_OpenCL = 6,
-    SourceLanguageSYCL = 7,
-    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,
-    ExecutionModelTaskEXT = 5364,
-    ExecutionModelMeshEXT = 5365,
-    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,
-    ExecutionModeNonCoherentColorAttachmentReadEXT = 4169,
-    ExecutionModeNonCoherentDepthAttachmentReadEXT = 4170,
-    ExecutionModeNonCoherentStencilAttachmentReadEXT = 4171,
-    ExecutionModeSubgroupUniformControlFlowKHR = 4421,
-    ExecutionModePostDepthCoverage = 4446,
-    ExecutionModeDenormPreserve = 4459,
-    ExecutionModeDenormFlushToZero = 4460,
-    ExecutionModeSignedZeroInfNanPreserve = 4461,
-    ExecutionModeRoundingModeRTE = 4462,
-    ExecutionModeRoundingModeRTZ = 4463,
-    ExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
-    ExecutionModeStencilRefReplacingEXT = 5027,
-    ExecutionModeStencilRefUnchangedFrontAMD = 5079,
-    ExecutionModeStencilRefGreaterFrontAMD = 5080,
-    ExecutionModeStencilRefLessFrontAMD = 5081,
-    ExecutionModeStencilRefUnchangedBackAMD = 5082,
-    ExecutionModeStencilRefGreaterBackAMD = 5083,
-    ExecutionModeStencilRefLessBackAMD = 5084,
-    ExecutionModeQuadDerivativesKHR = 5088,
-    ExecutionModeRequireFullQuadsKHR = 5089,
-    ExecutionModeOutputLinesEXT = 5269,
-    ExecutionModeOutputLinesNV = 5269,
-    ExecutionModeOutputPrimitivesEXT = 5270,
-    ExecutionModeOutputPrimitivesNV = 5270,
-    ExecutionModeDerivativeGroupQuadsNV = 5289,
-    ExecutionModeDerivativeGroupLinearNV = 5290,
-    ExecutionModeOutputTrianglesEXT = 5298,
-    ExecutionModeOutputTrianglesNV = 5298,
-    ExecutionModePixelInterlockOrderedEXT = 5366,
-    ExecutionModePixelInterlockUnorderedEXT = 5367,
-    ExecutionModeSampleInterlockOrderedEXT = 5368,
-    ExecutionModeSampleInterlockUnorderedEXT = 5369,
-    ExecutionModeShadingRateInterlockOrderedEXT = 5370,
-    ExecutionModeShadingRateInterlockUnorderedEXT = 5371,
-    ExecutionModeSharedLocalMemorySizeINTEL = 5618,
-    ExecutionModeRoundingModeRTPINTEL = 5620,
-    ExecutionModeRoundingModeRTNINTEL = 5621,
-    ExecutionModeFloatingPointModeALTINTEL = 5622,
-    ExecutionModeFloatingPointModeIEEEINTEL = 5623,
-    ExecutionModeMaxWorkgroupSizeINTEL = 5893,
-    ExecutionModeMaxWorkDimINTEL = 5894,
-    ExecutionModeNoGlobalOffsetINTEL = 5895,
-    ExecutionModeNumSIMDWorkitemsINTEL = 5896,
-    ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
-    ExecutionModeMaximallyReconvergesKHR = 6023,
-    ExecutionModeStreamingInterfaceINTEL = 6154,
-    ExecutionModeNamedBarrierCountINTEL = 6417,
-    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,
-    StorageClassTileImageEXT = 4172,
-    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,
-    StorageClassHitObjectAttributeNV = 5385,
-    StorageClassTaskPayloadWorkgroupEXT = 5402,
-    StorageClassCodeSectionINTEL = 5605,
-    StorageClassDeviceOnlyINTEL = 5936,
-    StorageClassHostOnlyINTEL = 5937,
-    StorageClassMax = 0x7fffffff,
-};
-
-enum Dim {
-    Dim1D = 0,
-    Dim2D = 1,
-    Dim3D = 2,
-    DimCube = 3,
-    DimRect = 4,
-    DimBuffer = 5,
-    DimSubpassData = 6,
-    DimTileImageDataEXT = 4173,
-    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,
-    ImageFormatR64ui = 40,
-    ImageFormatR64i = 41,
-    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,
-    ImageOperandsNontemporalShift = 14,
-    ImageOperandsOffsetsShift = 16,
-    ImageOperandsMax = 0x7fffffff,
-};
-
-enum ImageOperandsMask : unsigned {
-    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,
-    ImageOperandsNontemporalMask = 0x00004000,
-    ImageOperandsOffsetsMask = 0x00010000,
-};
-
-enum FPFastMathModeShift {
-    FPFastMathModeNotNaNShift = 0,
-    FPFastMathModeNotInfShift = 1,
-    FPFastMathModeNSZShift = 2,
-    FPFastMathModeAllowRecipShift = 3,
-    FPFastMathModeFastShift = 4,
-    FPFastMathModeAllowContractFastINTELShift = 16,
-    FPFastMathModeAllowReassocINTELShift = 17,
-    FPFastMathModeMax = 0x7fffffff,
-};
-
-enum FPFastMathModeMask : unsigned {
-    FPFastMathModeMaskNone = 0,
-    FPFastMathModeNotNaNMask = 0x00000001,
-    FPFastMathModeNotInfMask = 0x00000002,
-    FPFastMathModeNSZMask = 0x00000004,
-    FPFastMathModeAllowRecipMask = 0x00000008,
-    FPFastMathModeFastMask = 0x00000010,
-    FPFastMathModeAllowContractFastINTELMask = 0x00010000,
-    FPFastMathModeAllowReassocINTELMask = 0x00020000,
-};
-
-enum FPRoundingMode {
-    FPRoundingModeRTE = 0,
-    FPRoundingModeRTZ = 1,
-    FPRoundingModeRTP = 2,
-    FPRoundingModeRTN = 3,
-    FPRoundingModeMax = 0x7fffffff,
-};
-
-enum LinkageType {
-    LinkageTypeExport = 0,
-    LinkageTypeImport = 1,
-    LinkageTypeLinkOnceODR = 2,
-    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,
-    FunctionParameterAttributeRuntimeAlignedINTEL = 5940,
-    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,
-    DecorationWeightTextureQCOM = 4487,
-    DecorationBlockMatchTextureQCOM = 4488,
-    DecorationBlockMatchSamplerQCOM = 4499,
-    DecorationExplicitInterpAMD = 4999,
-    DecorationOverrideCoverageNV = 5248,
-    DecorationPassthroughNV = 5250,
-    DecorationViewportRelativeNV = 5252,
-    DecorationSecondaryViewportRelativeNV = 5256,
-    DecorationPerPrimitiveEXT = 5271,
-    DecorationPerPrimitiveNV = 5271,
-    DecorationPerViewNV = 5272,
-    DecorationPerTaskNV = 5273,
-    DecorationPerVertexKHR = 5285,
-    DecorationPerVertexNV = 5285,
-    DecorationNonUniform = 5300,
-    DecorationNonUniformEXT = 5300,
-    DecorationRestrictPointer = 5355,
-    DecorationRestrictPointerEXT = 5355,
-    DecorationAliasedPointer = 5356,
-    DecorationAliasedPointerEXT = 5356,
-    DecorationHitObjectShaderRecordBufferNV = 5386,
-    DecorationBindlessSamplerNV = 5398,
-    DecorationBindlessImageNV = 5399,
-    DecorationBoundSamplerNV = 5400,
-    DecorationBoundImageNV = 5401,
-    DecorationSIMTCallINTEL = 5599,
-    DecorationReferencedIndirectlyINTEL = 5602,
-    DecorationClobberINTEL = 5607,
-    DecorationSideEffectsINTEL = 5608,
-    DecorationVectorComputeVariableINTEL = 5624,
-    DecorationFuncParamIOKindINTEL = 5625,
-    DecorationVectorComputeFunctionINTEL = 5626,
-    DecorationStackCallINTEL = 5627,
-    DecorationGlobalVariableOffsetINTEL = 5628,
-    DecorationCounterBuffer = 5634,
-    DecorationHlslCounterBufferGOOGLE = 5634,
-    DecorationHlslSemanticGOOGLE = 5635,
-    DecorationUserSemantic = 5635,
-    DecorationUserTypeGOOGLE = 5636,
-    DecorationFunctionRoundingModeINTEL = 5822,
-    DecorationFunctionDenormModeINTEL = 5823,
-    DecorationRegisterINTEL = 5825,
-    DecorationMemoryINTEL = 5826,
-    DecorationNumbanksINTEL = 5827,
-    DecorationBankwidthINTEL = 5828,
-    DecorationMaxPrivateCopiesINTEL = 5829,
-    DecorationSinglepumpINTEL = 5830,
-    DecorationDoublepumpINTEL = 5831,
-    DecorationMaxReplicatesINTEL = 5832,
-    DecorationSimpleDualPortINTEL = 5833,
-    DecorationMergeINTEL = 5834,
-    DecorationBankBitsINTEL = 5835,
-    DecorationForcePow2DepthINTEL = 5836,
-    DecorationBurstCoalesceINTEL = 5899,
-    DecorationCacheSizeINTEL = 5900,
-    DecorationDontStaticallyCoalesceINTEL = 5901,
-    DecorationPrefetchINTEL = 5902,
-    DecorationStallEnableINTEL = 5905,
-    DecorationFuseLoopsInFunctionINTEL = 5907,
-    DecorationMathOpDSPModeINTEL = 5909,
-    DecorationAliasScopeINTEL = 5914,
-    DecorationNoAliasINTEL = 5915,
-    DecorationInitiationIntervalINTEL = 5917,
-    DecorationMaxConcurrencyINTEL = 5918,
-    DecorationPipelineEnableINTEL = 5919,
-    DecorationBufferLocationINTEL = 5921,
-    DecorationIOPipeStorageINTEL = 5944,
-    DecorationFunctionFloatingPointModeINTEL = 6080,
-    DecorationSingleElementVectorINTEL = 6085,
-    DecorationVectorComputeCallableFunctionINTEL = 6087,
-    DecorationMediaBlockIOINTEL = 6140,
-    DecorationConduitKernelArgumentINTEL = 6175,
-    DecorationRegisterMapKernelArgumentINTEL = 6176,
-    DecorationMMHostInterfaceAddressWidthINTEL = 6177,
-    DecorationMMHostInterfaceDataWidthINTEL = 6178,
-    DecorationMMHostInterfaceLatencyINTEL = 6179,
-    DecorationMMHostInterfaceReadWriteModeINTEL = 6180,
-    DecorationMMHostInterfaceMaxBurstINTEL = 6181,
-    DecorationMMHostInterfaceWaitRequestINTEL = 6182,
-    DecorationStableKernelArgumentINTEL = 6183,
-    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,
-    BuiltInCoreIDARM = 4160,
-    BuiltInCoreCountARM = 4161,
-    BuiltInCoreMaxIDARM = 4162,
-    BuiltInWarpIDARM = 4163,
-    BuiltInWarpMaxIDARM = 4164,
-    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,
-    BuiltInPrimitiveShadingRateKHR = 4432,
-    BuiltInDeviceIndex = 4438,
-    BuiltInViewIndex = 4440,
-    BuiltInShadingRateKHR = 4444,
-    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,
-    BuiltInBaryCoordKHR = 5286,
-    BuiltInBaryCoordNV = 5286,
-    BuiltInBaryCoordNoPerspKHR = 5287,
-    BuiltInBaryCoordNoPerspNV = 5287,
-    BuiltInFragSizeEXT = 5292,
-    BuiltInFragmentSizeNV = 5292,
-    BuiltInFragInvocationCountEXT = 5293,
-    BuiltInInvocationsPerPixelNV = 5293,
-    BuiltInPrimitivePointIndicesEXT = 5294,
-    BuiltInPrimitiveLineIndicesEXT = 5295,
-    BuiltInPrimitiveTriangleIndicesEXT = 5296,
-    BuiltInCullPrimitiveEXT = 5299,
-    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,
-    BuiltInHitTNV = 5332,
-    BuiltInHitKindKHR = 5333,
-    BuiltInHitKindNV = 5333,
-    BuiltInCurrentRayTimeNV = 5334,
-    BuiltInHitTriangleVertexPositionsKHR = 5335,
-    BuiltInHitMicroTriangleVertexPositionsNV = 5337,
-    BuiltInHitMicroTriangleVertexBarycentricsNV = 5344,
-    BuiltInIncomingRayFlagsKHR = 5351,
-    BuiltInIncomingRayFlagsNV = 5351,
-    BuiltInRayGeometryIndexKHR = 5352,
-    BuiltInWarpsPerSMNV = 5374,
-    BuiltInSMCountNV = 5375,
-    BuiltInWarpIDNV = 5376,
-    BuiltInSMIDNV = 5377,
-    BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
-    BuiltInHitKindBackFacingMicroTriangleNV = 5406,
-    BuiltInCullMaskKHR = 6021,
-    BuiltInMax = 0x7fffffff,
-};
-
-enum SelectionControlShift {
-    SelectionControlFlattenShift = 0,
-    SelectionControlDontFlattenShift = 1,
-    SelectionControlMax = 0x7fffffff,
-};
-
-enum SelectionControlMask : unsigned {
-    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,
-    LoopControlInitiationIntervalINTELShift = 16,
-    LoopControlMaxConcurrencyINTELShift = 17,
-    LoopControlDependencyArrayINTELShift = 18,
-    LoopControlPipelineEnableINTELShift = 19,
-    LoopControlLoopCoalesceINTELShift = 20,
-    LoopControlMaxInterleavingINTELShift = 21,
-    LoopControlSpeculatedIterationsINTELShift = 22,
-    LoopControlNoFusionINTELShift = 23,
-    LoopControlLoopCountINTELShift = 24,
-    LoopControlMaxReinvocationDelayINTELShift = 25,
-    LoopControlMax = 0x7fffffff,
-};
-
-enum LoopControlMask : unsigned {
-    LoopControlMaskNone = 0,
-    LoopControlUnrollMask = 0x00000001,
-    LoopControlDontUnrollMask = 0x00000002,
-    LoopControlDependencyInfiniteMask = 0x00000004,
-    LoopControlDependencyLengthMask = 0x00000008,
-    LoopControlMinIterationsMask = 0x00000010,
-    LoopControlMaxIterationsMask = 0x00000020,
-    LoopControlIterationMultipleMask = 0x00000040,
-    LoopControlPeelCountMask = 0x00000080,
-    LoopControlPartialCountMask = 0x00000100,
-    LoopControlInitiationIntervalINTELMask = 0x00010000,
-    LoopControlMaxConcurrencyINTELMask = 0x00020000,
-    LoopControlDependencyArrayINTELMask = 0x00040000,
-    LoopControlPipelineEnableINTELMask = 0x00080000,
-    LoopControlLoopCoalesceINTELMask = 0x00100000,
-    LoopControlMaxInterleavingINTELMask = 0x00200000,
-    LoopControlSpeculatedIterationsINTELMask = 0x00400000,
-    LoopControlNoFusionINTELMask = 0x00800000,
-    LoopControlLoopCountINTELMask = 0x01000000,
-    LoopControlMaxReinvocationDelayINTELMask = 0x02000000,
-};
-
-enum FunctionControlShift {
-    FunctionControlInlineShift = 0,
-    FunctionControlDontInlineShift = 1,
-    FunctionControlPureShift = 2,
-    FunctionControlConstShift = 3,
-    FunctionControlOptNoneINTELShift = 16,
-    FunctionControlMax = 0x7fffffff,
-};
-
-enum FunctionControlMask : unsigned {
-    FunctionControlMaskNone = 0,
-    FunctionControlInlineMask = 0x00000001,
-    FunctionControlDontInlineMask = 0x00000002,
-    FunctionControlPureMask = 0x00000004,
-    FunctionControlConstMask = 0x00000008,
-    FunctionControlOptNoneINTELMask = 0x00010000,
-};
-
-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 : unsigned {
-    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,
-    MemoryAccessAliasScopeINTELMaskShift = 16,
-    MemoryAccessNoAliasINTELMaskShift = 17,
-    MemoryAccessMax = 0x7fffffff,
-};
-
-enum MemoryAccessMask : unsigned {
-    MemoryAccessMaskNone = 0,
-    MemoryAccessVolatileMask = 0x00000001,
-    MemoryAccessAlignedMask = 0x00000002,
-    MemoryAccessNontemporalMask = 0x00000004,
-    MemoryAccessMakePointerAvailableMask = 0x00000008,
-    MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
-    MemoryAccessMakePointerVisibleMask = 0x00000010,
-    MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
-    MemoryAccessNonPrivatePointerMask = 0x00000020,
-    MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
-    MemoryAccessAliasScopeINTELMaskMask = 0x00010000,
-    MemoryAccessNoAliasINTELMaskMask = 0x00020000,
-};
-
-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 : unsigned {
-    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,
-    CapabilityUniformDecoration = 71,
-    CapabilityCoreBuiltinsARM = 4165,
-    CapabilityTileImageColorReadAccessEXT = 4166,
-    CapabilityTileImageDepthReadAccessEXT = 4167,
-    CapabilityTileImageStencilReadAccessEXT = 4168,
-    CapabilityCooperativeMatrixLayoutsARM = 4201,
-    CapabilityFragmentShadingRateKHR = 4422,
-    CapabilitySubgroupBallotKHR = 4423,
-    CapabilityDrawParameters = 4427,
-    CapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,
-    CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
-    CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
-    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,
-    CapabilityRayQueryKHR = 4472,
-    CapabilityRayTraversalPrimitiveCullingKHR = 4478,
-    CapabilityRayTracingKHR = 4479,
-    CapabilityTextureSampleWeightedQCOM = 4484,
-    CapabilityTextureBoxFilterQCOM = 4485,
-    CapabilityTextureBlockMatchQCOM = 4486,
-    CapabilityTextureBlockMatch2QCOM = 4498,
-    CapabilityFloat16ImageAMD = 5008,
-    CapabilityImageGatherBiasLodAMD = 5009,
-    CapabilityFragmentMaskAMD = 5010,
-    CapabilityStencilExportEXT = 5013,
-    CapabilityImageReadWriteLodAMD = 5015,
-    CapabilityInt64ImageEXT = 5016,
-    CapabilityShaderClockKHR = 5055,
-    CapabilityQuadControlKHR = 5087,
-    CapabilitySampleMaskOverrideCoverageNV = 5249,
-    CapabilityGeometryShaderPassthroughNV = 5251,
-    CapabilityShaderViewportIndexLayerEXT = 5254,
-    CapabilityShaderViewportIndexLayerNV = 5254,
-    CapabilityShaderViewportMaskNV = 5255,
-    CapabilityShaderStereoViewNV = 5259,
-    CapabilityPerViewAttributesNV = 5260,
-    CapabilityFragmentFullyCoveredEXT = 5265,
-    CapabilityMeshShadingNV = 5266,
-    CapabilityImageFootprintNV = 5282,
-    CapabilityMeshShadingEXT = 5283,
-    CapabilityFragmentBarycentricKHR = 5284,
-    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,
-    CapabilityRayTracingPositionFetchKHR = 5336,
-    CapabilityRayTracingNV = 5340,
-    CapabilityRayTracingMotionBlurNV = 5341,
-    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,
-    CapabilityDemoteToHelperInvocation = 5379,
-    CapabilityDemoteToHelperInvocationEXT = 5379,
-    CapabilityDisplacementMicromapNV = 5380,
-    CapabilityRayTracingOpacityMicromapEXT = 5381,
-    CapabilityShaderInvocationReorderNV = 5383,
-    CapabilityBindlessTextureNV = 5390,
-    CapabilityRayQueryPositionFetchKHR = 5391,
-    CapabilityAtomicFloat16VectorNV = 5404,
-    CapabilityRayTracingDisplacementMicromapNV = 5409,
-    CapabilitySubgroupShuffleINTEL = 5568,
-    CapabilitySubgroupBufferBlockIOINTEL = 5569,
-    CapabilitySubgroupImageBlockIOINTEL = 5570,
-    CapabilitySubgroupImageMediaBlockIOINTEL = 5579,
-    CapabilityRoundToInfinityINTEL = 5582,
-    CapabilityFloatingPointModeINTEL = 5583,
-    CapabilityIntegerFunctions2INTEL = 5584,
-    CapabilityFunctionPointersINTEL = 5603,
-    CapabilityIndirectReferencesINTEL = 5604,
-    CapabilityAsmINTEL = 5606,
-    CapabilityAtomicFloat32MinMaxEXT = 5612,
-    CapabilityAtomicFloat64MinMaxEXT = 5613,
-    CapabilityAtomicFloat16MinMaxEXT = 5616,
-    CapabilityVectorComputeINTEL = 5617,
-    CapabilityVectorAnyINTEL = 5619,
-    CapabilityExpectAssumeKHR = 5629,
-    CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
-    CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
-    CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
-    CapabilityVariableLengthArrayINTEL = 5817,
-    CapabilityFunctionFloatControlINTEL = 5821,
-    CapabilityFPGAMemoryAttributesINTEL = 5824,
-    CapabilityFPFastMathModeINTEL = 5837,
-    CapabilityArbitraryPrecisionIntegersINTEL = 5844,
-    CapabilityArbitraryPrecisionFloatingPointINTEL = 5845,
-    CapabilityUnstructuredLoopControlsINTEL = 5886,
-    CapabilityFPGALoopControlsINTEL = 5888,
-    CapabilityKernelAttributesINTEL = 5892,
-    CapabilityFPGAKernelAttributesINTEL = 5897,
-    CapabilityFPGAMemoryAccessesINTEL = 5898,
-    CapabilityFPGAClusterAttributesINTEL = 5904,
-    CapabilityLoopFuseINTEL = 5906,
-    CapabilityFPGADSPControlINTEL = 5908,
-    CapabilityMemoryAccessAliasingINTEL = 5910,
-    CapabilityFPGAInvocationPipeliningAttributesINTEL = 5916,
-    CapabilityFPGABufferLocationINTEL = 5920,
-    CapabilityArbitraryPrecisionFixedPointINTEL = 5922,
-    CapabilityUSMStorageClassesINTEL = 5935,
-    CapabilityRuntimeAlignedAttributeINTEL = 5939,
-    CapabilityIOPipesINTEL = 5943,
-    CapabilityBlockingPipesINTEL = 5945,
-    CapabilityFPGARegINTEL = 5948,
-    CapabilityDotProductInputAll = 6016,
-    CapabilityDotProductInputAllKHR = 6016,
-    CapabilityDotProductInput4x8Bit = 6017,
-    CapabilityDotProductInput4x8BitKHR = 6017,
-    CapabilityDotProductInput4x8BitPacked = 6018,
-    CapabilityDotProductInput4x8BitPackedKHR = 6018,
-    CapabilityDotProduct = 6019,
-    CapabilityDotProductKHR = 6019,
-    CapabilityRayCullMaskKHR = 6020,
-    CapabilityCooperativeMatrixKHR = 6022,
-    CapabilityReplicatedCompositesEXT = 6024,
-    CapabilityBitInstructions = 6025,
-    CapabilityGroupNonUniformRotateKHR = 6026,
-    CapabilityAtomicFloat32AddEXT = 6033,
-    CapabilityAtomicFloat64AddEXT = 6034,
-    CapabilityLongConstantCompositeINTEL = 6089,
-    CapabilityOptNoneINTEL = 6094,
-    CapabilityAtomicFloat16AddEXT = 6095,
-    CapabilityDebugInfoModuleINTEL = 6114,
-    CapabilitySplitBarrierINTEL = 6141,
-    CapabilityFPGAArgumentInterfacesINTEL = 6174,
-    CapabilityGroupUniformArithmeticKHR = 6400,
-    CapabilityMax = 0x7fffffff,
-};
-
-enum RayFlagsShift {
-    RayFlagsOpaqueKHRShift = 0,
-    RayFlagsNoOpaqueKHRShift = 1,
-    RayFlagsTerminateOnFirstHitKHRShift = 2,
-    RayFlagsSkipClosestHitShaderKHRShift = 3,
-    RayFlagsCullBackFacingTrianglesKHRShift = 4,
-    RayFlagsCullFrontFacingTrianglesKHRShift = 5,
-    RayFlagsCullOpaqueKHRShift = 6,
-    RayFlagsCullNoOpaqueKHRShift = 7,
-    RayFlagsSkipTrianglesKHRShift = 8,
-    RayFlagsSkipAABBsKHRShift = 9,
-    RayFlagsForceOpacityMicromap2StateEXTShift = 10,
-    RayFlagsMax = 0x7fffffff,
-};
-
-enum RayFlagsMask : unsigned {
-    RayFlagsMaskNone = 0,
-    RayFlagsOpaqueKHRMask = 0x00000001,
-    RayFlagsNoOpaqueKHRMask = 0x00000002,
-    RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
-    RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
-    RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
-    RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
-    RayFlagsCullOpaqueKHRMask = 0x00000040,
-    RayFlagsCullNoOpaqueKHRMask = 0x00000080,
-    RayFlagsSkipTrianglesKHRMask = 0x00000100,
-    RayFlagsSkipAABBsKHRMask = 0x00000200,
-    RayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
-};
-
-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 FragmentShadingRateShift {
-    FragmentShadingRateVertical2PixelsShift = 0,
-    FragmentShadingRateVertical4PixelsShift = 1,
-    FragmentShadingRateHorizontal2PixelsShift = 2,
-    FragmentShadingRateHorizontal4PixelsShift = 3,
-    FragmentShadingRateMax = 0x7fffffff,
-};
-
-enum FragmentShadingRateMask : unsigned {
-    FragmentShadingRateMaskNone = 0,
-    FragmentShadingRateVertical2PixelsMask = 0x00000001,
-    FragmentShadingRateVertical4PixelsMask = 0x00000002,
-    FragmentShadingRateHorizontal2PixelsMask = 0x00000004,
-    FragmentShadingRateHorizontal4PixelsMask = 0x00000008,
-};
-
-enum FPDenormMode {
-    FPDenormModePreserve = 0,
-    FPDenormModeFlushToZero = 1,
-    FPDenormModeMax = 0x7fffffff,
-};
-
-enum FPOperationMode {
-    FPOperationModeIEEE = 0,
-    FPOperationModeALT = 1,
-    FPOperationModeMax = 0x7fffffff,
-};
-
-enum QuantizationModes {
-    QuantizationModesTRN = 0,
-    QuantizationModesTRN_ZERO = 1,
-    QuantizationModesRND = 2,
-    QuantizationModesRND_ZERO = 3,
-    QuantizationModesRND_INF = 4,
-    QuantizationModesRND_MIN_INF = 5,
-    QuantizationModesRND_CONV = 6,
-    QuantizationModesRND_CONV_ODD = 7,
-    QuantizationModesMax = 0x7fffffff,
-};
-
-enum OverflowModes {
-    OverflowModesWRAP = 0,
-    OverflowModesSAT = 1,
-    OverflowModesSAT_ZERO = 2,
-    OverflowModesSAT_SYM = 3,
-    OverflowModesMax = 0x7fffffff,
-};
-
-enum PackedVectorFormat {
-    PackedVectorFormatPackedVectorFormat4x8Bit = 0,
-    PackedVectorFormatPackedVectorFormat4x8BitKHR = 0,
-    PackedVectorFormatMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixOperandsShift {
-    CooperativeMatrixOperandsMatrixASignedComponentsKHRShift = 0,
-    CooperativeMatrixOperandsMatrixBSignedComponentsKHRShift = 1,
-    CooperativeMatrixOperandsMatrixCSignedComponentsKHRShift = 2,
-    CooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift = 3,
-    CooperativeMatrixOperandsSaturatingAccumulationKHRShift = 4,
-    CooperativeMatrixOperandsMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixOperandsMask : unsigned {
-    CooperativeMatrixOperandsMaskNone = 0,
-    CooperativeMatrixOperandsMatrixASignedComponentsKHRMask = 0x00000001,
-    CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask = 0x00000002,
-    CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask = 0x00000004,
-    CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask = 0x00000008,
-    CooperativeMatrixOperandsSaturatingAccumulationKHRMask = 0x00000010,
-};
-
-enum CooperativeMatrixLayout {
-    CooperativeMatrixLayoutRowMajorKHR = 0,
-    CooperativeMatrixLayoutColumnMajorKHR = 1,
-    CooperativeMatrixLayoutRowBlockedInterleavedARM = 4202,
-    CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203,
-    CooperativeMatrixLayoutMax = 0x7fffffff,
-};
-
-enum CooperativeMatrixUse {
-    CooperativeMatrixUseMatrixAKHR = 0,
-    CooperativeMatrixUseMatrixBKHR = 1,
-    CooperativeMatrixUseMatrixAccumulatorKHR = 2,
-    CooperativeMatrixUseMax = 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,
-    OpColorAttachmentReadEXT = 4160,
-    OpDepthAttachmentReadEXT = 4161,
-    OpStencilAttachmentReadEXT = 4162,
-    OpTerminateInvocation = 4416,
-    OpSubgroupBallotKHR = 4421,
-    OpSubgroupFirstInvocationKHR = 4422,
-    OpSubgroupAllKHR = 4428,
-    OpSubgroupAnyKHR = 4429,
-    OpSubgroupAllEqualKHR = 4430,
-    OpGroupNonUniformRotateKHR = 4431,
-    OpSubgroupReadInvocationKHR = 4432,
-    OpExtInstWithForwardRefsKHR = 4433,
-    OpTraceRayKHR = 4445,
-    OpExecuteCallableKHR = 4446,
-    OpConvertUToAccelerationStructureKHR = 4447,
-    OpIgnoreIntersectionKHR = 4448,
-    OpTerminateRayKHR = 4449,
-    OpSDot = 4450,
-    OpSDotKHR = 4450,
-    OpUDot = 4451,
-    OpUDotKHR = 4451,
-    OpSUDot = 4452,
-    OpSUDotKHR = 4452,
-    OpSDotAccSat = 4453,
-    OpSDotAccSatKHR = 4453,
-    OpUDotAccSat = 4454,
-    OpUDotAccSatKHR = 4454,
-    OpSUDotAccSat = 4455,
-    OpSUDotAccSatKHR = 4455,
-    OpTypeCooperativeMatrixKHR = 4456,
-    OpCooperativeMatrixLoadKHR = 4457,
-    OpCooperativeMatrixStoreKHR = 4458,
-    OpCooperativeMatrixMulAddKHR = 4459,
-    OpCooperativeMatrixLengthKHR = 4460,
-    OpConstantCompositeReplicateEXT = 4461,
-    OpSpecConstantCompositeReplicateEXT = 4462,
-    OpCompositeConstructReplicateEXT = 4463,
-    OpTypeRayQueryKHR = 4472,
-    OpRayQueryInitializeKHR = 4473,
-    OpRayQueryTerminateKHR = 4474,
-    OpRayQueryGenerateIntersectionKHR = 4475,
-    OpRayQueryConfirmIntersectionKHR = 4476,
-    OpRayQueryProceedKHR = 4477,
-    OpRayQueryGetIntersectionTypeKHR = 4479,
-    OpImageSampleWeightedQCOM = 4480,
-    OpImageBoxFilterQCOM = 4481,
-    OpImageBlockMatchSSDQCOM = 4482,
-    OpImageBlockMatchSADQCOM = 4483,
-    OpImageBlockMatchWindowSSDQCOM = 4500,
-    OpImageBlockMatchWindowSADQCOM = 4501,
-    OpImageBlockMatchGatherSSDQCOM = 4502,
-    OpImageBlockMatchGatherSADQCOM = 4503,
-    OpGroupIAddNonUniformAMD = 5000,
-    OpGroupFAddNonUniformAMD = 5001,
-    OpGroupFMinNonUniformAMD = 5002,
-    OpGroupUMinNonUniformAMD = 5003,
-    OpGroupSMinNonUniformAMD = 5004,
-    OpGroupFMaxNonUniformAMD = 5005,
-    OpGroupUMaxNonUniformAMD = 5006,
-    OpGroupSMaxNonUniformAMD = 5007,
-    OpFragmentMaskFetchAMD = 5011,
-    OpFragmentFetchAMD = 5012,
-    OpReadClockKHR = 5056,
-    OpGroupNonUniformQuadAllKHR = 5110,
-    OpGroupNonUniformQuadAnyKHR = 5111,
-    OpHitObjectRecordHitMotionNV = 5249,
-    OpHitObjectRecordHitWithIndexMotionNV = 5250,
-    OpHitObjectRecordMissMotionNV = 5251,
-    OpHitObjectGetWorldToObjectNV = 5252,
-    OpHitObjectGetObjectToWorldNV = 5253,
-    OpHitObjectGetObjectRayDirectionNV = 5254,
-    OpHitObjectGetObjectRayOriginNV = 5255,
-    OpHitObjectTraceRayMotionNV = 5256,
-    OpHitObjectGetShaderRecordBufferHandleNV = 5257,
-    OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
-    OpHitObjectRecordEmptyNV = 5259,
-    OpHitObjectTraceRayNV = 5260,
-    OpHitObjectRecordHitNV = 5261,
-    OpHitObjectRecordHitWithIndexNV = 5262,
-    OpHitObjectRecordMissNV = 5263,
-    OpHitObjectExecuteShaderNV = 5264,
-    OpHitObjectGetCurrentTimeNV = 5265,
-    OpHitObjectGetAttributesNV = 5266,
-    OpHitObjectGetHitKindNV = 5267,
-    OpHitObjectGetPrimitiveIndexNV = 5268,
-    OpHitObjectGetGeometryIndexNV = 5269,
-    OpHitObjectGetInstanceIdNV = 5270,
-    OpHitObjectGetInstanceCustomIndexNV = 5271,
-    OpHitObjectGetWorldRayDirectionNV = 5272,
-    OpHitObjectGetWorldRayOriginNV = 5273,
-    OpHitObjectGetRayTMaxNV = 5274,
-    OpHitObjectGetRayTMinNV = 5275,
-    OpHitObjectIsEmptyNV = 5276,
-    OpHitObjectIsHitNV = 5277,
-    OpHitObjectIsMissNV = 5278,
-    OpReorderThreadWithHitObjectNV = 5279,
-    OpReorderThreadWithHintNV = 5280,
-    OpTypeHitObjectNV = 5281,
-    OpImageSampleFootprintNV = 5283,
-    OpEmitMeshTasksEXT = 5294,
-    OpSetMeshOutputsEXT = 5295,
-    OpGroupNonUniformPartitionNV = 5296,
-    OpWritePackedPrimitiveIndices4x8NV = 5299,
-    OpFetchMicroTriangleVertexPositionNV = 5300,
-    OpFetchMicroTriangleVertexBarycentricNV = 5301,
-    OpReportIntersectionKHR = 5334,
-    OpReportIntersectionNV = 5334,
-    OpIgnoreIntersectionNV = 5335,
-    OpTerminateRayNV = 5336,
-    OpTraceNV = 5337,
-    OpTraceMotionNV = 5338,
-    OpTraceRayMotionNV = 5339,
-    OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
-    OpTypeAccelerationStructureKHR = 5341,
-    OpTypeAccelerationStructureNV = 5341,
-    OpExecuteCallableNV = 5344,
-    OpTypeCooperativeMatrixNV = 5358,
-    OpCooperativeMatrixLoadNV = 5359,
-    OpCooperativeMatrixStoreNV = 5360,
-    OpCooperativeMatrixMulAddNV = 5361,
-    OpCooperativeMatrixLengthNV = 5362,
-    OpBeginInvocationInterlockEXT = 5364,
-    OpEndInvocationInterlockEXT = 5365,
-    OpDemoteToHelperInvocation = 5380,
-    OpDemoteToHelperInvocationEXT = 5380,
-    OpIsHelperInvocationEXT = 5381,
-    OpConvertUToImageNV = 5391,
-    OpConvertUToSamplerNV = 5392,
-    OpConvertImageToUNV = 5393,
-    OpConvertSamplerToUNV = 5394,
-    OpConvertUToSampledImageNV = 5395,
-    OpConvertSampledImageToUNV = 5396,
-    OpSamplerImageAddressingModeNV = 5397,
-    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,
-    OpConstantFunctionPointerINTEL = 5600,
-    OpFunctionPointerCallINTEL = 5601,
-    OpAsmTargetINTEL = 5609,
-    OpAsmINTEL = 5610,
-    OpAsmCallINTEL = 5611,
-    OpAtomicFMinEXT = 5614,
-    OpAtomicFMaxEXT = 5615,
-    OpAssumeTrueKHR = 5630,
-    OpExpectKHR = 5631,
-    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,
-    OpVariableLengthArrayINTEL = 5818,
-    OpSaveMemoryINTEL = 5819,
-    OpRestoreMemoryINTEL = 5820,
-    OpArbitraryFloatSinCosPiINTEL = 5840,
-    OpArbitraryFloatCastINTEL = 5841,
-    OpArbitraryFloatCastFromIntINTEL = 5842,
-    OpArbitraryFloatCastToIntINTEL = 5843,
-    OpArbitraryFloatAddINTEL = 5846,
-    OpArbitraryFloatSubINTEL = 5847,
-    OpArbitraryFloatMulINTEL = 5848,
-    OpArbitraryFloatDivINTEL = 5849,
-    OpArbitraryFloatGTINTEL = 5850,
-    OpArbitraryFloatGEINTEL = 5851,
-    OpArbitraryFloatLTINTEL = 5852,
-    OpArbitraryFloatLEINTEL = 5853,
-    OpArbitraryFloatEQINTEL = 5854,
-    OpArbitraryFloatRecipINTEL = 5855,
-    OpArbitraryFloatRSqrtINTEL = 5856,
-    OpArbitraryFloatCbrtINTEL = 5857,
-    OpArbitraryFloatHypotINTEL = 5858,
-    OpArbitraryFloatSqrtINTEL = 5859,
-    OpArbitraryFloatLogINTEL = 5860,
-    OpArbitraryFloatLog2INTEL = 5861,
-    OpArbitraryFloatLog10INTEL = 5862,
-    OpArbitraryFloatLog1pINTEL = 5863,
-    OpArbitraryFloatExpINTEL = 5864,
-    OpArbitraryFloatExp2INTEL = 5865,
-    OpArbitraryFloatExp10INTEL = 5866,
-    OpArbitraryFloatExpm1INTEL = 5867,
-    OpArbitraryFloatSinINTEL = 5868,
-    OpArbitraryFloatCosINTEL = 5869,
-    OpArbitraryFloatSinCosINTEL = 5870,
-    OpArbitraryFloatSinPiINTEL = 5871,
-    OpArbitraryFloatCosPiINTEL = 5872,
-    OpArbitraryFloatASinINTEL = 5873,
-    OpArbitraryFloatASinPiINTEL = 5874,
-    OpArbitraryFloatACosINTEL = 5875,
-    OpArbitraryFloatACosPiINTEL = 5876,
-    OpArbitraryFloatATanINTEL = 5877,
-    OpArbitraryFloatATanPiINTEL = 5878,
-    OpArbitraryFloatATan2INTEL = 5879,
-    OpArbitraryFloatPowINTEL = 5880,
-    OpArbitraryFloatPowRINTEL = 5881,
-    OpArbitraryFloatPowNINTEL = 5882,
-    OpLoopControlINTEL = 5887,
-    OpAliasDomainDeclINTEL = 5911,
-    OpAliasScopeDeclINTEL = 5912,
-    OpAliasScopeListDeclINTEL = 5913,
-    OpFixedSqrtINTEL = 5923,
-    OpFixedRecipINTEL = 5924,
-    OpFixedRsqrtINTEL = 5925,
-    OpFixedSinINTEL = 5926,
-    OpFixedCosINTEL = 5927,
-    OpFixedSinCosINTEL = 5928,
-    OpFixedSinPiINTEL = 5929,
-    OpFixedCosPiINTEL = 5930,
-    OpFixedSinCosPiINTEL = 5931,
-    OpFixedLogINTEL = 5932,
-    OpFixedExpINTEL = 5933,
-    OpPtrCastToCrossWorkgroupINTEL = 5934,
-    OpCrossWorkgroupCastToPtrINTEL = 5938,
-    OpReadPipeBlockingINTEL = 5946,
-    OpWritePipeBlockingINTEL = 5947,
-    OpFPGARegINTEL = 5949,
-    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,
-    OpAtomicFAddEXT = 6035,
-    OpTypeBufferSurfaceINTEL = 6086,
-    OpTypeStructContinuedINTEL = 6090,
-    OpConstantCompositeContinuedINTEL = 6091,
-    OpSpecConstantCompositeContinuedINTEL = 6092,
-    OpControlBarrierArriveINTEL = 6142,
-    OpControlBarrierWaitINTEL = 6143,
-    OpGroupIMulKHR = 6401,
-    OpGroupFMulKHR = 6402,
-    OpGroupBitwiseAndKHR = 6403,
-    OpGroupBitwiseOrKHR = 6404,
-    OpGroupBitwiseXorKHR = 6405,
-    OpGroupLogicalAndKHR = 6406,
-    OpGroupLogicalOrKHR = 6407,
-    OpGroupLogicalXorKHR = 6408,
-    OpMax = 0x7fffffff,
-};
-
-#ifdef SPV_ENABLE_UTILITY_CODE
-#ifndef __cplusplus
-#include <stdbool.h>
-#endif
-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 OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break;
-    case OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTerminateInvocation: *hasResult = false; *hasResultType = false; 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 OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
-    case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
-    case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
-    case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
-    case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
-    case OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
-    case OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
-    case OpSDot: *hasResult = true; *hasResultType = true; break;
-    case OpUDot: *hasResult = true; *hasResultType = true; break;
-    case OpSUDot: *hasResult = true; *hasResultType = true; break;
-    case OpSDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case OpUDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;
-    case OpTypeCooperativeMatrixKHR: *hasResult = true; *hasResultType = false; break;
-    case OpCooperativeMatrixLoadKHR: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break;
-    case OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break;
-    case OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break;
-    case OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
-    case OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
-    case OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTypeRayQueryKHR: *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 OpImageSampleWeightedQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break;
-    case OpImageBlockMatchGatherSADQCOM: *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 OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetWorldToObjectNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetObjectToWorldNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetObjectRayDirectionNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetObjectRayOriginNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetShaderRecordBufferHandleNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetShaderBindingTableRecordIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectRecordEmptyNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectTraceRayNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordHitNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordHitWithIndexNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectRecordMissNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectExecuteShaderNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetCurrentTimeNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetAttributesNV: *hasResult = false; *hasResultType = false; break;
-    case OpHitObjectGetHitKindNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetPrimitiveIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetGeometryIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetInstanceIdNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetInstanceCustomIndexNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetWorldRayDirectionNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetWorldRayOriginNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetRayTMaxNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectGetRayTMinNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
-    case OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
-    case OpReorderThreadWithHitObjectNV: *hasResult = false; *hasResultType = false; break;
-    case OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
-    case OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
-    case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
-    case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
-    case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; 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 OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
-    case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; 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 OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
-    case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;
-    case OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
-    case OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; 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 OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
-    case OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
-    case OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
-    case OpExpectKHR: *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 OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpAliasDomainDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpAliasScopeDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpAliasScopeListDeclINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
-    case OpFPGARegINTEL: *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;
-    case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
-    case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
-    case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
-    case OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBitwiseOrKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupBitwiseXorKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break;
-    case OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break;
-    }
-}
-#endif /* SPV_ENABLE_UTILITY_CODE */
-
-// Overload bitwise operators for mask bit combining
-
-inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
-inline ImageOperandsMask operator&(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) & unsigned(b)); }
-inline ImageOperandsMask operator^(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) ^ unsigned(b)); }
-inline ImageOperandsMask operator~(ImageOperandsMask a) { return ImageOperandsMask(~unsigned(a)); }
-inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
-inline FPFastMathModeMask operator&(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) & unsigned(b)); }
-inline FPFastMathModeMask operator^(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) ^ unsigned(b)); }
-inline FPFastMathModeMask operator~(FPFastMathModeMask a) { return FPFastMathModeMask(~unsigned(a)); }
-inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
-inline SelectionControlMask operator&(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) & unsigned(b)); }
-inline SelectionControlMask operator^(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) ^ unsigned(b)); }
-inline SelectionControlMask operator~(SelectionControlMask a) { return SelectionControlMask(~unsigned(a)); }
-inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
-inline LoopControlMask operator&(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) & unsigned(b)); }
-inline LoopControlMask operator^(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) ^ unsigned(b)); }
-inline LoopControlMask operator~(LoopControlMask a) { return LoopControlMask(~unsigned(a)); }
-inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
-inline FunctionControlMask operator&(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) & unsigned(b)); }
-inline FunctionControlMask operator^(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) ^ unsigned(b)); }
-inline FunctionControlMask operator~(FunctionControlMask a) { return FunctionControlMask(~unsigned(a)); }
-inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
-inline MemorySemanticsMask operator&(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) & unsigned(b)); }
-inline MemorySemanticsMask operator^(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) ^ unsigned(b)); }
-inline MemorySemanticsMask operator~(MemorySemanticsMask a) { return MemorySemanticsMask(~unsigned(a)); }
-inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
-inline MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) & unsigned(b)); }
-inline MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) ^ unsigned(b)); }
-inline MemoryAccessMask operator~(MemoryAccessMask a) { return MemoryAccessMask(~unsigned(a)); }
-inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
-inline KernelProfilingInfoMask operator&(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) & unsigned(b)); }
-inline KernelProfilingInfoMask operator^(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b)); }
-inline KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) { return KernelProfilingInfoMask(~unsigned(a)); }
-inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
-inline RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) & unsigned(b)); }
-inline RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) ^ unsigned(b)); }
-inline RayFlagsMask operator~(RayFlagsMask a) { return RayFlagsMask(~unsigned(a)); }
-inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
-inline FragmentShadingRateMask operator&(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) & unsigned(b)); }
-inline FragmentShadingRateMask operator^(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) ^ unsigned(b)); }
-inline FragmentShadingRateMask operator~(FragmentShadingRateMask a) { return FragmentShadingRateMask(~unsigned(a)); }
-inline CooperativeMatrixOperandsMask operator|(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) | unsigned(b)); }
-inline CooperativeMatrixOperandsMask operator&(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) & unsigned(b)); }
-inline CooperativeMatrixOperandsMask operator^(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) ^ unsigned(b)); }
-inline CooperativeMatrixOperandsMask operator~(CooperativeMatrixOperandsMask a) { return CooperativeMatrixOperandsMask(~unsigned(a)); }
-
-}  // end namespace spv
-
-#endif  // #ifndef spirv_HPP
-

+ 5186 - 0
src/libraries/glslang/SPIRV/spirv.hpp11

@@ -0,0 +1,5186 @@
+// Copyright (c) 2014-2024 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, Beef
+// 
+// - 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
+// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
+//     e.g.: Spv.Specification.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 0x10600
+#define SPV_REVISION 1
+
+static const unsigned int MagicNumber = 0x07230203;
+static const unsigned int Version = 0x00010600;
+static const unsigned int Revision = 1;
+static const unsigned int OpCodeMask = 0xffff;
+static const unsigned int WordCountShift = 16;
+
+enum class SourceLanguage : unsigned {
+    Unknown = 0,
+    ESSL = 1,
+    GLSL = 2,
+    OpenCL_C = 3,
+    OpenCL_CPP = 4,
+    HLSL = 5,
+    CPP_for_OpenCL = 6,
+    SYCL = 7,
+    HERO_C = 8,
+    NZSL = 9,
+    WGSL = 10,
+    Slang = 11,
+    Zig = 12,
+    Rust = 13,
+    Max = 0x7fffffff,
+};
+
+enum class ExecutionModel : unsigned {
+    Vertex = 0,
+    TessellationControl = 1,
+    TessellationEvaluation = 2,
+    Geometry = 3,
+    Fragment = 4,
+    GLCompute = 5,
+    Kernel = 6,
+    TaskNV = 5267,
+    MeshNV = 5268,
+    RayGenerationKHR = 5313,
+    RayGenerationNV = 5313,
+    IntersectionKHR = 5314,
+    IntersectionNV = 5314,
+    AnyHitKHR = 5315,
+    AnyHitNV = 5315,
+    ClosestHitKHR = 5316,
+    ClosestHitNV = 5316,
+    MissKHR = 5317,
+    MissNV = 5317,
+    CallableKHR = 5318,
+    CallableNV = 5318,
+    TaskEXT = 5364,
+    MeshEXT = 5365,
+    Max = 0x7fffffff,
+};
+
+enum class AddressingModel : unsigned {
+    Logical = 0,
+    Physical32 = 1,
+    Physical64 = 2,
+    PhysicalStorageBuffer64 = 5348,
+    PhysicalStorageBuffer64EXT = 5348,
+    Max = 0x7fffffff,
+};
+
+enum class MemoryModel : unsigned {
+    Simple = 0,
+    GLSL450 = 1,
+    OpenCL = 2,
+    Vulkan = 3,
+    VulkanKHR = 3,
+    Max = 0x7fffffff,
+};
+
+enum class ExecutionMode : unsigned {
+    Invocations = 0,
+    SpacingEqual = 1,
+    SpacingFractionalEven = 2,
+    SpacingFractionalOdd = 3,
+    VertexOrderCw = 4,
+    VertexOrderCcw = 5,
+    PixelCenterInteger = 6,
+    OriginUpperLeft = 7,
+    OriginLowerLeft = 8,
+    EarlyFragmentTests = 9,
+    PointMode = 10,
+    Xfb = 11,
+    DepthReplacing = 12,
+    DepthGreater = 14,
+    DepthLess = 15,
+    DepthUnchanged = 16,
+    LocalSize = 17,
+    LocalSizeHint = 18,
+    InputPoints = 19,
+    InputLines = 20,
+    InputLinesAdjacency = 21,
+    Triangles = 22,
+    InputTrianglesAdjacency = 23,
+    Quads = 24,
+    Isolines = 25,
+    OutputVertices = 26,
+    OutputPoints = 27,
+    OutputLineStrip = 28,
+    OutputTriangleStrip = 29,
+    VecTypeHint = 30,
+    ContractionOff = 31,
+    Initializer = 33,
+    Finalizer = 34,
+    SubgroupSize = 35,
+    SubgroupsPerWorkgroup = 36,
+    SubgroupsPerWorkgroupId = 37,
+    LocalSizeId = 38,
+    LocalSizeHintId = 39,
+    NonCoherentColorAttachmentReadEXT = 4169,
+    NonCoherentDepthAttachmentReadEXT = 4170,
+    NonCoherentStencilAttachmentReadEXT = 4171,
+    SubgroupUniformControlFlowKHR = 4421,
+    PostDepthCoverage = 4446,
+    DenormPreserve = 4459,
+    DenormFlushToZero = 4460,
+    SignedZeroInfNanPreserve = 4461,
+    RoundingModeRTE = 4462,
+    RoundingModeRTZ = 4463,
+    NonCoherentTileAttachmentReadQCOM = 4489,
+    TileShadingRateQCOM = 4490,
+    EarlyAndLateFragmentTestsAMD = 5017,
+    StencilRefReplacingEXT = 5027,
+    CoalescingAMDX = 5069,
+    IsApiEntryAMDX = 5070,
+    MaxNodeRecursionAMDX = 5071,
+    StaticNumWorkgroupsAMDX = 5072,
+    ShaderIndexAMDX = 5073,
+    MaxNumWorkgroupsAMDX = 5077,
+    StencilRefUnchangedFrontAMD = 5079,
+    StencilRefGreaterFrontAMD = 5080,
+    StencilRefLessFrontAMD = 5081,
+    StencilRefUnchangedBackAMD = 5082,
+    StencilRefGreaterBackAMD = 5083,
+    StencilRefLessBackAMD = 5084,
+    QuadDerivativesKHR = 5088,
+    RequireFullQuadsKHR = 5089,
+    SharesInputWithAMDX = 5102,
+    OutputLinesEXT = 5269,
+    OutputLinesNV = 5269,
+    OutputPrimitivesEXT = 5270,
+    OutputPrimitivesNV = 5270,
+    DerivativeGroupQuadsKHR = 5289,
+    DerivativeGroupQuadsNV = 5289,
+    DerivativeGroupLinearKHR = 5290,
+    DerivativeGroupLinearNV = 5290,
+    OutputTrianglesEXT = 5298,
+    OutputTrianglesNV = 5298,
+    PixelInterlockOrderedEXT = 5366,
+    PixelInterlockUnorderedEXT = 5367,
+    SampleInterlockOrderedEXT = 5368,
+    SampleInterlockUnorderedEXT = 5369,
+    ShadingRateInterlockOrderedEXT = 5370,
+    ShadingRateInterlockUnorderedEXT = 5371,
+    SharedLocalMemorySizeINTEL = 5618,
+    RoundingModeRTPINTEL = 5620,
+    RoundingModeRTNINTEL = 5621,
+    FloatingPointModeALTINTEL = 5622,
+    FloatingPointModeIEEEINTEL = 5623,
+    MaxWorkgroupSizeINTEL = 5893,
+    MaxWorkDimINTEL = 5894,
+    NoGlobalOffsetINTEL = 5895,
+    NumSIMDWorkitemsINTEL = 5896,
+    SchedulerTargetFmaxMhzINTEL = 5903,
+    MaximallyReconvergesKHR = 6023,
+    FPFastMathDefault = 6028,
+    StreamingInterfaceINTEL = 6154,
+    RegisterMapInterfaceINTEL = 6160,
+    NamedBarrierCountINTEL = 6417,
+    MaximumRegistersINTEL = 6461,
+    MaximumRegistersIdINTEL = 6462,
+    NamedMaximumRegistersINTEL = 6463,
+    Max = 0x7fffffff,
+};
+
+enum class StorageClass : unsigned {
+    UniformConstant = 0,
+    Input = 1,
+    Uniform = 2,
+    Output = 3,
+    Workgroup = 4,
+    CrossWorkgroup = 5,
+    Private = 6,
+    Function = 7,
+    Generic = 8,
+    PushConstant = 9,
+    AtomicCounter = 10,
+    Image = 11,
+    StorageBuffer = 12,
+    TileImageEXT = 4172,
+    TileAttachmentQCOM = 4491,
+    NodePayloadAMDX = 5068,
+    CallableDataKHR = 5328,
+    CallableDataNV = 5328,
+    IncomingCallableDataKHR = 5329,
+    IncomingCallableDataNV = 5329,
+    RayPayloadKHR = 5338,
+    RayPayloadNV = 5338,
+    HitAttributeKHR = 5339,
+    HitAttributeNV = 5339,
+    IncomingRayPayloadKHR = 5342,
+    IncomingRayPayloadNV = 5342,
+    ShaderRecordBufferKHR = 5343,
+    ShaderRecordBufferNV = 5343,
+    PhysicalStorageBuffer = 5349,
+    PhysicalStorageBufferEXT = 5349,
+    HitObjectAttributeNV = 5385,
+    TaskPayloadWorkgroupEXT = 5402,
+    CodeSectionINTEL = 5605,
+    DeviceOnlyINTEL = 5936,
+    HostOnlyINTEL = 5937,
+    Max = 0x7fffffff,
+};
+
+enum class Dim : unsigned {
+    Dim1D = 0,
+    Dim2D = 1,
+    Dim3D = 2,
+    Cube = 3,
+    Rect = 4,
+    Buffer = 5,
+    SubpassData = 6,
+    TileImageDataEXT = 4173,
+    Max = 0x7fffffff,
+};
+
+enum class SamplerAddressingMode : unsigned {
+    None = 0,
+    ClampToEdge = 1,
+    Clamp = 2,
+    Repeat = 3,
+    RepeatMirrored = 4,
+    Max = 0x7fffffff,
+};
+
+enum class SamplerFilterMode : unsigned {
+    Nearest = 0,
+    Linear = 1,
+    Max = 0x7fffffff,
+};
+
+enum class ImageFormat : unsigned {
+    Unknown = 0,
+    Rgba32f = 1,
+    Rgba16f = 2,
+    R32f = 3,
+    Rgba8 = 4,
+    Rgba8Snorm = 5,
+    Rg32f = 6,
+    Rg16f = 7,
+    R11fG11fB10f = 8,
+    R16f = 9,
+    Rgba16 = 10,
+    Rgb10A2 = 11,
+    Rg16 = 12,
+    Rg8 = 13,
+    R16 = 14,
+    R8 = 15,
+    Rgba16Snorm = 16,
+    Rg16Snorm = 17,
+    Rg8Snorm = 18,
+    R16Snorm = 19,
+    R8Snorm = 20,
+    Rgba32i = 21,
+    Rgba16i = 22,
+    Rgba8i = 23,
+    R32i = 24,
+    Rg32i = 25,
+    Rg16i = 26,
+    Rg8i = 27,
+    R16i = 28,
+    R8i = 29,
+    Rgba32ui = 30,
+    Rgba16ui = 31,
+    Rgba8ui = 32,
+    R32ui = 33,
+    Rgb10a2ui = 34,
+    Rg32ui = 35,
+    Rg16ui = 36,
+    Rg8ui = 37,
+    R16ui = 38,
+    R8ui = 39,
+    R64ui = 40,
+    R64i = 41,
+    Max = 0x7fffffff,
+};
+
+enum class ImageChannelOrder : unsigned {
+    R = 0,
+    A = 1,
+    RG = 2,
+    RA = 3,
+    RGB = 4,
+    RGBA = 5,
+    BGRA = 6,
+    ARGB = 7,
+    Intensity = 8,
+    Luminance = 9,
+    Rx = 10,
+    RGx = 11,
+    RGBx = 12,
+    Depth = 13,
+    DepthStencil = 14,
+    sRGB = 15,
+    sRGBx = 16,
+    sRGBA = 17,
+    sBGRA = 18,
+    ABGR = 19,
+    Max = 0x7fffffff,
+};
+
+enum class ImageChannelDataType : unsigned {
+    SnormInt8 = 0,
+    SnormInt16 = 1,
+    UnormInt8 = 2,
+    UnormInt16 = 3,
+    UnormShort565 = 4,
+    UnormShort555 = 5,
+    UnormInt101010 = 6,
+    SignedInt8 = 7,
+    SignedInt16 = 8,
+    SignedInt32 = 9,
+    UnsignedInt8 = 10,
+    UnsignedInt16 = 11,
+    UnsignedInt32 = 12,
+    HalfFloat = 13,
+    Float = 14,
+    UnormInt24 = 15,
+    UnormInt101010_2 = 16,
+    UnsignedIntRaw10EXT = 19,
+    UnsignedIntRaw12EXT = 20,
+    UnormInt2_101010EXT = 21,
+    Max = 0x7fffffff,
+};
+
+enum class ImageOperandsShift : unsigned {
+    Bias = 0,
+    Lod = 1,
+    Grad = 2,
+    ConstOffset = 3,
+    Offset = 4,
+    ConstOffsets = 5,
+    Sample = 6,
+    MinLod = 7,
+    MakeTexelAvailable = 8,
+    MakeTexelAvailableKHR = 8,
+    MakeTexelVisible = 9,
+    MakeTexelVisibleKHR = 9,
+    NonPrivateTexel = 10,
+    NonPrivateTexelKHR = 10,
+    VolatileTexel = 11,
+    VolatileTexelKHR = 11,
+    SignExtend = 12,
+    ZeroExtend = 13,
+    Nontemporal = 14,
+    Offsets = 16,
+    Max = 0x7fffffff,
+};
+
+enum class ImageOperandsMask : unsigned {
+    MaskNone = 0,
+    Bias = 0x00000001,
+    Lod = 0x00000002,
+    Grad = 0x00000004,
+    ConstOffset = 0x00000008,
+    Offset = 0x00000010,
+    ConstOffsets = 0x00000020,
+    Sample = 0x00000040,
+    MinLod = 0x00000080,
+    MakeTexelAvailable = 0x00000100,
+    MakeTexelAvailableKHR = 0x00000100,
+    MakeTexelVisible = 0x00000200,
+    MakeTexelVisibleKHR = 0x00000200,
+    NonPrivateTexel = 0x00000400,
+    NonPrivateTexelKHR = 0x00000400,
+    VolatileTexel = 0x00000800,
+    VolatileTexelKHR = 0x00000800,
+    SignExtend = 0x00001000,
+    ZeroExtend = 0x00002000,
+    Nontemporal = 0x00004000,
+    Offsets = 0x00010000,
+};
+
+enum class FPFastMathModeShift : unsigned {
+    NotNaN = 0,
+    NotInf = 1,
+    NSZ = 2,
+    AllowRecip = 3,
+    Fast = 4,
+    AllowContract = 16,
+    AllowContractFastINTEL = 16,
+    AllowReassoc = 17,
+    AllowReassocINTEL = 17,
+    AllowTransform = 18,
+    Max = 0x7fffffff,
+};
+
+enum class FPFastMathModeMask : unsigned {
+    MaskNone = 0,
+    NotNaN = 0x00000001,
+    NotInf = 0x00000002,
+    NSZ = 0x00000004,
+    AllowRecip = 0x00000008,
+    Fast = 0x00000010,
+    AllowContract = 0x00010000,
+    AllowContractFastINTEL = 0x00010000,
+    AllowReassoc = 0x00020000,
+    AllowReassocINTEL = 0x00020000,
+    AllowTransform = 0x00040000,
+};
+
+enum class FPRoundingMode : unsigned {
+    RTE = 0,
+    RTZ = 1,
+    RTP = 2,
+    RTN = 3,
+    Max = 0x7fffffff,
+};
+
+enum class LinkageType : unsigned {
+    Export = 0,
+    Import = 1,
+    LinkOnceODR = 2,
+    Max = 0x7fffffff,
+};
+
+enum class AccessQualifier : unsigned {
+    ReadOnly = 0,
+    WriteOnly = 1,
+    ReadWrite = 2,
+    Max = 0x7fffffff,
+};
+
+enum class FunctionParameterAttribute : unsigned {
+    Zext = 0,
+    Sext = 1,
+    ByVal = 2,
+    Sret = 3,
+    NoAlias = 4,
+    NoCapture = 5,
+    NoWrite = 6,
+    NoReadWrite = 7,
+    RuntimeAlignedINTEL = 5940,
+    Max = 0x7fffffff,
+};
+
+enum class Decoration : unsigned {
+    RelaxedPrecision = 0,
+    SpecId = 1,
+    Block = 2,
+    BufferBlock = 3,
+    RowMajor = 4,
+    ColMajor = 5,
+    ArrayStride = 6,
+    MatrixStride = 7,
+    GLSLShared = 8,
+    GLSLPacked = 9,
+    CPacked = 10,
+    BuiltIn = 11,
+    NoPerspective = 13,
+    Flat = 14,
+    Patch = 15,
+    Centroid = 16,
+    Sample = 17,
+    Invariant = 18,
+    Restrict = 19,
+    Aliased = 20,
+    Volatile = 21,
+    Constant = 22,
+    Coherent = 23,
+    NonWritable = 24,
+    NonReadable = 25,
+    Uniform = 26,
+    UniformId = 27,
+    SaturatedConversion = 28,
+    Stream = 29,
+    Location = 30,
+    Component = 31,
+    Index = 32,
+    Binding = 33,
+    DescriptorSet = 34,
+    Offset = 35,
+    XfbBuffer = 36,
+    XfbStride = 37,
+    FuncParamAttr = 38,
+    FPRoundingMode = 39,
+    FPFastMathMode = 40,
+    LinkageAttributes = 41,
+    NoContraction = 42,
+    InputAttachmentIndex = 43,
+    Alignment = 44,
+    MaxByteOffset = 45,
+    AlignmentId = 46,
+    MaxByteOffsetId = 47,
+    SaturatedToLargestFloat8NormalConversionEXT = 4216,
+    NoSignedWrap = 4469,
+    NoUnsignedWrap = 4470,
+    WeightTextureQCOM = 4487,
+    BlockMatchTextureQCOM = 4488,
+    BlockMatchSamplerQCOM = 4499,
+    ExplicitInterpAMD = 4999,
+    NodeSharesPayloadLimitsWithAMDX = 5019,
+    NodeMaxPayloadsAMDX = 5020,
+    TrackFinishWritingAMDX = 5078,
+    PayloadNodeNameAMDX = 5091,
+    PayloadNodeBaseIndexAMDX = 5098,
+    PayloadNodeSparseArrayAMDX = 5099,
+    PayloadNodeArraySizeAMDX = 5100,
+    PayloadDispatchIndirectAMDX = 5105,
+    OverrideCoverageNV = 5248,
+    PassthroughNV = 5250,
+    ViewportRelativeNV = 5252,
+    SecondaryViewportRelativeNV = 5256,
+    PerPrimitiveEXT = 5271,
+    PerPrimitiveNV = 5271,
+    PerViewNV = 5272,
+    PerTaskNV = 5273,
+    PerVertexKHR = 5285,
+    PerVertexNV = 5285,
+    NonUniform = 5300,
+    NonUniformEXT = 5300,
+    RestrictPointer = 5355,
+    RestrictPointerEXT = 5355,
+    AliasedPointer = 5356,
+    AliasedPointerEXT = 5356,
+    HitObjectShaderRecordBufferNV = 5386,
+    BindlessSamplerNV = 5398,
+    BindlessImageNV = 5399,
+    BoundSamplerNV = 5400,
+    BoundImageNV = 5401,
+    SIMTCallINTEL = 5599,
+    ReferencedIndirectlyINTEL = 5602,
+    ClobberINTEL = 5607,
+    SideEffectsINTEL = 5608,
+    VectorComputeVariableINTEL = 5624,
+    FuncParamIOKindINTEL = 5625,
+    VectorComputeFunctionINTEL = 5626,
+    StackCallINTEL = 5627,
+    GlobalVariableOffsetINTEL = 5628,
+    CounterBuffer = 5634,
+    HlslCounterBufferGOOGLE = 5634,
+    HlslSemanticGOOGLE = 5635,
+    UserSemantic = 5635,
+    UserTypeGOOGLE = 5636,
+    FunctionRoundingModeINTEL = 5822,
+    FunctionDenormModeINTEL = 5823,
+    RegisterINTEL = 5825,
+    MemoryINTEL = 5826,
+    NumbanksINTEL = 5827,
+    BankwidthINTEL = 5828,
+    MaxPrivateCopiesINTEL = 5829,
+    SinglepumpINTEL = 5830,
+    DoublepumpINTEL = 5831,
+    MaxReplicatesINTEL = 5832,
+    SimpleDualPortINTEL = 5833,
+    MergeINTEL = 5834,
+    BankBitsINTEL = 5835,
+    ForcePow2DepthINTEL = 5836,
+    StridesizeINTEL = 5883,
+    WordsizeINTEL = 5884,
+    TrueDualPortINTEL = 5885,
+    BurstCoalesceINTEL = 5899,
+    CacheSizeINTEL = 5900,
+    DontStaticallyCoalesceINTEL = 5901,
+    PrefetchINTEL = 5902,
+    StallEnableINTEL = 5905,
+    FuseLoopsInFunctionINTEL = 5907,
+    MathOpDSPModeINTEL = 5909,
+    AliasScopeINTEL = 5914,
+    NoAliasINTEL = 5915,
+    InitiationIntervalINTEL = 5917,
+    MaxConcurrencyINTEL = 5918,
+    PipelineEnableINTEL = 5919,
+    BufferLocationINTEL = 5921,
+    IOPipeStorageINTEL = 5944,
+    FunctionFloatingPointModeINTEL = 6080,
+    SingleElementVectorINTEL = 6085,
+    VectorComputeCallableFunctionINTEL = 6087,
+    MediaBlockIOINTEL = 6140,
+    StallFreeINTEL = 6151,
+    FPMaxErrorDecorationINTEL = 6170,
+    LatencyControlLabelINTEL = 6172,
+    LatencyControlConstraintINTEL = 6173,
+    ConduitKernelArgumentINTEL = 6175,
+    RegisterMapKernelArgumentINTEL = 6176,
+    MMHostInterfaceAddressWidthINTEL = 6177,
+    MMHostInterfaceDataWidthINTEL = 6178,
+    MMHostInterfaceLatencyINTEL = 6179,
+    MMHostInterfaceReadWriteModeINTEL = 6180,
+    MMHostInterfaceMaxBurstINTEL = 6181,
+    MMHostInterfaceWaitRequestINTEL = 6182,
+    StableKernelArgumentINTEL = 6183,
+    HostAccessINTEL = 6188,
+    InitModeINTEL = 6190,
+    ImplementInRegisterMapINTEL = 6191,
+    CacheControlLoadINTEL = 6442,
+    CacheControlStoreINTEL = 6443,
+    Max = 0x7fffffff,
+};
+
+enum class BuiltIn : unsigned {
+    Position = 0,
+    PointSize = 1,
+    ClipDistance = 3,
+    CullDistance = 4,
+    VertexId = 5,
+    InstanceId = 6,
+    PrimitiveId = 7,
+    InvocationId = 8,
+    Layer = 9,
+    ViewportIndex = 10,
+    TessLevelOuter = 11,
+    TessLevelInner = 12,
+    TessCoord = 13,
+    PatchVertices = 14,
+    FragCoord = 15,
+    PointCoord = 16,
+    FrontFacing = 17,
+    SampleId = 18,
+    SamplePosition = 19,
+    SampleMask = 20,
+    FragDepth = 22,
+    HelperInvocation = 23,
+    NumWorkgroups = 24,
+    WorkgroupSize = 25,
+    WorkgroupId = 26,
+    LocalInvocationId = 27,
+    GlobalInvocationId = 28,
+    LocalInvocationIndex = 29,
+    WorkDim = 30,
+    GlobalSize = 31,
+    EnqueuedWorkgroupSize = 32,
+    GlobalOffset = 33,
+    GlobalLinearId = 34,
+    SubgroupSize = 36,
+    SubgroupMaxSize = 37,
+    NumSubgroups = 38,
+    NumEnqueuedSubgroups = 39,
+    SubgroupId = 40,
+    SubgroupLocalInvocationId = 41,
+    VertexIndex = 42,
+    InstanceIndex = 43,
+    CoreIDARM = 4160,
+    CoreCountARM = 4161,
+    CoreMaxIDARM = 4162,
+    WarpIDARM = 4163,
+    WarpMaxIDARM = 4164,
+    SubgroupEqMask = 4416,
+    SubgroupEqMaskKHR = 4416,
+    SubgroupGeMask = 4417,
+    SubgroupGeMaskKHR = 4417,
+    SubgroupGtMask = 4418,
+    SubgroupGtMaskKHR = 4418,
+    SubgroupLeMask = 4419,
+    SubgroupLeMaskKHR = 4419,
+    SubgroupLtMask = 4420,
+    SubgroupLtMaskKHR = 4420,
+    BaseVertex = 4424,
+    BaseInstance = 4425,
+    DrawIndex = 4426,
+    PrimitiveShadingRateKHR = 4432,
+    DeviceIndex = 4438,
+    ViewIndex = 4440,
+    ShadingRateKHR = 4444,
+    TileOffsetQCOM = 4492,
+    TileDimensionQCOM = 4493,
+    TileApronSizeQCOM = 4494,
+    BaryCoordNoPerspAMD = 4992,
+    BaryCoordNoPerspCentroidAMD = 4993,
+    BaryCoordNoPerspSampleAMD = 4994,
+    BaryCoordSmoothAMD = 4995,
+    BaryCoordSmoothCentroidAMD = 4996,
+    BaryCoordSmoothSampleAMD = 4997,
+    BaryCoordPullModelAMD = 4998,
+    FragStencilRefEXT = 5014,
+    RemainingRecursionLevelsAMDX = 5021,
+    ShaderIndexAMDX = 5073,
+    ViewportMaskNV = 5253,
+    SecondaryPositionNV = 5257,
+    SecondaryViewportMaskNV = 5258,
+    PositionPerViewNV = 5261,
+    ViewportMaskPerViewNV = 5262,
+    FullyCoveredEXT = 5264,
+    TaskCountNV = 5274,
+    PrimitiveCountNV = 5275,
+    PrimitiveIndicesNV = 5276,
+    ClipDistancePerViewNV = 5277,
+    CullDistancePerViewNV = 5278,
+    LayerPerViewNV = 5279,
+    MeshViewCountNV = 5280,
+    MeshViewIndicesNV = 5281,
+    BaryCoordKHR = 5286,
+    BaryCoordNV = 5286,
+    BaryCoordNoPerspKHR = 5287,
+    BaryCoordNoPerspNV = 5287,
+    FragSizeEXT = 5292,
+    FragmentSizeNV = 5292,
+    FragInvocationCountEXT = 5293,
+    InvocationsPerPixelNV = 5293,
+    PrimitivePointIndicesEXT = 5294,
+    PrimitiveLineIndicesEXT = 5295,
+    PrimitiveTriangleIndicesEXT = 5296,
+    CullPrimitiveEXT = 5299,
+    LaunchIdKHR = 5319,
+    LaunchIdNV = 5319,
+    LaunchSizeKHR = 5320,
+    LaunchSizeNV = 5320,
+    WorldRayOriginKHR = 5321,
+    WorldRayOriginNV = 5321,
+    WorldRayDirectionKHR = 5322,
+    WorldRayDirectionNV = 5322,
+    ObjectRayOriginKHR = 5323,
+    ObjectRayOriginNV = 5323,
+    ObjectRayDirectionKHR = 5324,
+    ObjectRayDirectionNV = 5324,
+    RayTminKHR = 5325,
+    RayTminNV = 5325,
+    RayTmaxKHR = 5326,
+    RayTmaxNV = 5326,
+    InstanceCustomIndexKHR = 5327,
+    InstanceCustomIndexNV = 5327,
+    ObjectToWorldKHR = 5330,
+    ObjectToWorldNV = 5330,
+    WorldToObjectKHR = 5331,
+    WorldToObjectNV = 5331,
+    HitTNV = 5332,
+    HitKindKHR = 5333,
+    HitKindNV = 5333,
+    CurrentRayTimeNV = 5334,
+    HitTriangleVertexPositionsKHR = 5335,
+    HitMicroTriangleVertexPositionsNV = 5337,
+    HitMicroTriangleVertexBarycentricsNV = 5344,
+    IncomingRayFlagsKHR = 5351,
+    IncomingRayFlagsNV = 5351,
+    RayGeometryIndexKHR = 5352,
+    HitIsSphereNV = 5359,
+    HitIsLSSNV = 5360,
+    HitSpherePositionNV = 5361,
+    WarpsPerSMNV = 5374,
+    SMCountNV = 5375,
+    WarpIDNV = 5376,
+    SMIDNV = 5377,
+    HitLSSPositionsNV = 5396,
+    HitKindFrontFacingMicroTriangleNV = 5405,
+    HitKindBackFacingMicroTriangleNV = 5406,
+    HitSphereRadiusNV = 5420,
+    HitLSSRadiiNV = 5421,
+    ClusterIDNV = 5436,
+    CullMaskKHR = 6021,
+    Max = 0x7fffffff,
+};
+
+enum class SelectionControlShift : unsigned {
+    Flatten = 0,
+    DontFlatten = 1,
+    Max = 0x7fffffff,
+};
+
+enum class SelectionControlMask : unsigned {
+    MaskNone = 0,
+    Flatten = 0x00000001,
+    DontFlatten = 0x00000002,
+};
+
+enum class LoopControlShift : unsigned {
+    Unroll = 0,
+    DontUnroll = 1,
+    DependencyInfinite = 2,
+    DependencyLength = 3,
+    MinIterations = 4,
+    MaxIterations = 5,
+    IterationMultiple = 6,
+    PeelCount = 7,
+    PartialCount = 8,
+    InitiationIntervalINTEL = 16,
+    MaxConcurrencyINTEL = 17,
+    DependencyArrayINTEL = 18,
+    PipelineEnableINTEL = 19,
+    LoopCoalesceINTEL = 20,
+    MaxInterleavingINTEL = 21,
+    SpeculatedIterationsINTEL = 22,
+    NoFusionINTEL = 23,
+    LoopCountINTEL = 24,
+    MaxReinvocationDelayINTEL = 25,
+    Max = 0x7fffffff,
+};
+
+enum class LoopControlMask : unsigned {
+    MaskNone = 0,
+    Unroll = 0x00000001,
+    DontUnroll = 0x00000002,
+    DependencyInfinite = 0x00000004,
+    DependencyLength = 0x00000008,
+    MinIterations = 0x00000010,
+    MaxIterations = 0x00000020,
+    IterationMultiple = 0x00000040,
+    PeelCount = 0x00000080,
+    PartialCount = 0x00000100,
+    InitiationIntervalINTEL = 0x00010000,
+    MaxConcurrencyINTEL = 0x00020000,
+    DependencyArrayINTEL = 0x00040000,
+    PipelineEnableINTEL = 0x00080000,
+    LoopCoalesceINTEL = 0x00100000,
+    MaxInterleavingINTEL = 0x00200000,
+    SpeculatedIterationsINTEL = 0x00400000,
+    NoFusionINTEL = 0x00800000,
+    LoopCountINTEL = 0x01000000,
+    MaxReinvocationDelayINTEL = 0x02000000,
+};
+
+enum class FunctionControlShift : unsigned {
+    Inline = 0,
+    DontInline = 1,
+    Pure = 2,
+    Const = 3,
+    OptNoneEXT = 16,
+    OptNoneINTEL = 16,
+    Max = 0x7fffffff,
+};
+
+enum class FunctionControlMask : unsigned {
+    MaskNone = 0,
+    Inline = 0x00000001,
+    DontInline = 0x00000002,
+    Pure = 0x00000004,
+    Const = 0x00000008,
+    OptNoneEXT = 0x00010000,
+    OptNoneINTEL = 0x00010000,
+};
+
+enum class MemorySemanticsShift : unsigned {
+    Acquire = 1,
+    Release = 2,
+    AcquireRelease = 3,
+    SequentiallyConsistent = 4,
+    UniformMemory = 6,
+    SubgroupMemory = 7,
+    WorkgroupMemory = 8,
+    CrossWorkgroupMemory = 9,
+    AtomicCounterMemory = 10,
+    ImageMemory = 11,
+    OutputMemory = 12,
+    OutputMemoryKHR = 12,
+    MakeAvailable = 13,
+    MakeAvailableKHR = 13,
+    MakeVisible = 14,
+    MakeVisibleKHR = 14,
+    Volatile = 15,
+    Max = 0x7fffffff,
+};
+
+enum class MemorySemanticsMask : unsigned {
+    MaskNone = 0,
+    Acquire = 0x00000002,
+    Release = 0x00000004,
+    AcquireRelease = 0x00000008,
+    SequentiallyConsistent = 0x00000010,
+    UniformMemory = 0x00000040,
+    SubgroupMemory = 0x00000080,
+    WorkgroupMemory = 0x00000100,
+    CrossWorkgroupMemory = 0x00000200,
+    AtomicCounterMemory = 0x00000400,
+    ImageMemory = 0x00000800,
+    OutputMemory = 0x00001000,
+    OutputMemoryKHR = 0x00001000,
+    MakeAvailable = 0x00002000,
+    MakeAvailableKHR = 0x00002000,
+    MakeVisible = 0x00004000,
+    MakeVisibleKHR = 0x00004000,
+    Volatile = 0x00008000,
+};
+
+enum class MemoryAccessShift : unsigned {
+    Volatile = 0,
+    Aligned = 1,
+    Nontemporal = 2,
+    MakePointerAvailable = 3,
+    MakePointerAvailableKHR = 3,
+    MakePointerVisible = 4,
+    MakePointerVisibleKHR = 4,
+    NonPrivatePointer = 5,
+    NonPrivatePointerKHR = 5,
+    AliasScopeINTELMask = 16,
+    NoAliasINTELMask = 17,
+    Max = 0x7fffffff,
+};
+
+enum class MemoryAccessMask : unsigned {
+    MaskNone = 0,
+    Volatile = 0x00000001,
+    Aligned = 0x00000002,
+    Nontemporal = 0x00000004,
+    MakePointerAvailable = 0x00000008,
+    MakePointerAvailableKHR = 0x00000008,
+    MakePointerVisible = 0x00000010,
+    MakePointerVisibleKHR = 0x00000010,
+    NonPrivatePointer = 0x00000020,
+    NonPrivatePointerKHR = 0x00000020,
+    AliasScopeINTELMask = 0x00010000,
+    NoAliasINTELMask = 0x00020000,
+};
+
+enum class Scope : unsigned {
+    CrossDevice = 0,
+    Device = 1,
+    Workgroup = 2,
+    Subgroup = 3,
+    Invocation = 4,
+    QueueFamily = 5,
+    QueueFamilyKHR = 5,
+    ShaderCallKHR = 6,
+    Max = 0x7fffffff,
+};
+
+enum class GroupOperation : unsigned {
+    Reduce = 0,
+    InclusiveScan = 1,
+    ExclusiveScan = 2,
+    ClusteredReduce = 3,
+    PartitionedReduceNV = 6,
+    PartitionedInclusiveScanNV = 7,
+    PartitionedExclusiveScanNV = 8,
+    Max = 0x7fffffff,
+};
+
+enum class KernelEnqueueFlags : unsigned {
+    NoWait = 0,
+    WaitKernel = 1,
+    WaitWorkGroup = 2,
+    Max = 0x7fffffff,
+};
+
+enum class KernelProfilingInfoShift : unsigned {
+    CmdExecTime = 0,
+    Max = 0x7fffffff,
+};
+
+enum class KernelProfilingInfoMask : unsigned {
+    MaskNone = 0,
+    CmdExecTime = 0x00000001,
+};
+
+enum class Capability : unsigned {
+    Matrix = 0,
+    Shader = 1,
+    Geometry = 2,
+    Tessellation = 3,
+    Addresses = 4,
+    Linkage = 5,
+    Kernel = 6,
+    Vector16 = 7,
+    Float16Buffer = 8,
+    Float16 = 9,
+    Float64 = 10,
+    Int64 = 11,
+    Int64Atomics = 12,
+    ImageBasic = 13,
+    ImageReadWrite = 14,
+    ImageMipmap = 15,
+    Pipes = 17,
+    Groups = 18,
+    DeviceEnqueue = 19,
+    LiteralSampler = 20,
+    AtomicStorage = 21,
+    Int16 = 22,
+    TessellationPointSize = 23,
+    GeometryPointSize = 24,
+    ImageGatherExtended = 25,
+    StorageImageMultisample = 27,
+    UniformBufferArrayDynamicIndexing = 28,
+    SampledImageArrayDynamicIndexing = 29,
+    StorageBufferArrayDynamicIndexing = 30,
+    StorageImageArrayDynamicIndexing = 31,
+    ClipDistance = 32,
+    CullDistance = 33,
+    ImageCubeArray = 34,
+    SampleRateShading = 35,
+    ImageRect = 36,
+    SampledRect = 37,
+    GenericPointer = 38,
+    Int8 = 39,
+    InputAttachment = 40,
+    SparseResidency = 41,
+    MinLod = 42,
+    Sampled1D = 43,
+    Image1D = 44,
+    SampledCubeArray = 45,
+    SampledBuffer = 46,
+    ImageBuffer = 47,
+    ImageMSArray = 48,
+    StorageImageExtendedFormats = 49,
+    ImageQuery = 50,
+    DerivativeControl = 51,
+    InterpolationFunction = 52,
+    TransformFeedback = 53,
+    GeometryStreams = 54,
+    StorageImageReadWithoutFormat = 55,
+    StorageImageWriteWithoutFormat = 56,
+    MultiViewport = 57,
+    SubgroupDispatch = 58,
+    NamedBarrier = 59,
+    PipeStorage = 60,
+    GroupNonUniform = 61,
+    GroupNonUniformVote = 62,
+    GroupNonUniformArithmetic = 63,
+    GroupNonUniformBallot = 64,
+    GroupNonUniformShuffle = 65,
+    GroupNonUniformShuffleRelative = 66,
+    GroupNonUniformClustered = 67,
+    GroupNonUniformQuad = 68,
+    ShaderLayer = 69,
+    ShaderViewportIndex = 70,
+    UniformDecoration = 71,
+    CoreBuiltinsARM = 4165,
+    TileImageColorReadAccessEXT = 4166,
+    TileImageDepthReadAccessEXT = 4167,
+    TileImageStencilReadAccessEXT = 4168,
+    CooperativeMatrixLayoutsARM = 4201,
+    Float8EXT = 4212,
+    Float8CooperativeMatrixEXT = 4213,
+    FragmentShadingRateKHR = 4422,
+    SubgroupBallotKHR = 4423,
+    DrawParameters = 4427,
+    WorkgroupMemoryExplicitLayoutKHR = 4428,
+    WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
+    WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
+    SubgroupVoteKHR = 4431,
+    StorageBuffer16BitAccess = 4433,
+    StorageUniformBufferBlock16 = 4433,
+    StorageUniform16 = 4434,
+    UniformAndStorageBuffer16BitAccess = 4434,
+    StoragePushConstant16 = 4435,
+    StorageInputOutput16 = 4436,
+    DeviceGroup = 4437,
+    MultiView = 4439,
+    VariablePointersStorageBuffer = 4441,
+    VariablePointers = 4442,
+    AtomicStorageOps = 4445,
+    SampleMaskPostDepthCoverage = 4447,
+    StorageBuffer8BitAccess = 4448,
+    UniformAndStorageBuffer8BitAccess = 4449,
+    StoragePushConstant8 = 4450,
+    DenormPreserve = 4464,
+    DenormFlushToZero = 4465,
+    SignedZeroInfNanPreserve = 4466,
+    RoundingModeRTE = 4467,
+    RoundingModeRTZ = 4468,
+    RayQueryProvisionalKHR = 4471,
+    RayQueryKHR = 4472,
+    UntypedPointersKHR = 4473,
+    RayTraversalPrimitiveCullingKHR = 4478,
+    RayTracingKHR = 4479,
+    TextureSampleWeightedQCOM = 4484,
+    TextureBoxFilterQCOM = 4485,
+    TextureBlockMatchQCOM = 4486,
+    TileShadingQCOM = 4495,
+    TextureBlockMatch2QCOM = 4498,
+    Float16ImageAMD = 5008,
+    ImageGatherBiasLodAMD = 5009,
+    FragmentMaskAMD = 5010,
+    StencilExportEXT = 5013,
+    ImageReadWriteLodAMD = 5015,
+    Int64ImageEXT = 5016,
+    ShaderClockKHR = 5055,
+    ShaderEnqueueAMDX = 5067,
+    QuadControlKHR = 5087,
+    BFloat16TypeKHR = 5116,
+    BFloat16DotProductKHR = 5117,
+    BFloat16CooperativeMatrixKHR = 5118,
+    SampleMaskOverrideCoverageNV = 5249,
+    GeometryShaderPassthroughNV = 5251,
+    ShaderViewportIndexLayerEXT = 5254,
+    ShaderViewportIndexLayerNV = 5254,
+    ShaderViewportMaskNV = 5255,
+    ShaderStereoViewNV = 5259,
+    PerViewAttributesNV = 5260,
+    FragmentFullyCoveredEXT = 5265,
+    MeshShadingNV = 5266,
+    ImageFootprintNV = 5282,
+    MeshShadingEXT = 5283,
+    FragmentBarycentricKHR = 5284,
+    FragmentBarycentricNV = 5284,
+    ComputeDerivativeGroupQuadsKHR = 5288,
+    ComputeDerivativeGroupQuadsNV = 5288,
+    FragmentDensityEXT = 5291,
+    ShadingRateNV = 5291,
+    GroupNonUniformPartitionedNV = 5297,
+    ShaderNonUniform = 5301,
+    ShaderNonUniformEXT = 5301,
+    RuntimeDescriptorArray = 5302,
+    RuntimeDescriptorArrayEXT = 5302,
+    InputAttachmentArrayDynamicIndexing = 5303,
+    InputAttachmentArrayDynamicIndexingEXT = 5303,
+    UniformTexelBufferArrayDynamicIndexing = 5304,
+    UniformTexelBufferArrayDynamicIndexingEXT = 5304,
+    StorageTexelBufferArrayDynamicIndexing = 5305,
+    StorageTexelBufferArrayDynamicIndexingEXT = 5305,
+    UniformBufferArrayNonUniformIndexing = 5306,
+    UniformBufferArrayNonUniformIndexingEXT = 5306,
+    SampledImageArrayNonUniformIndexing = 5307,
+    SampledImageArrayNonUniformIndexingEXT = 5307,
+    StorageBufferArrayNonUniformIndexing = 5308,
+    StorageBufferArrayNonUniformIndexingEXT = 5308,
+    StorageImageArrayNonUniformIndexing = 5309,
+    StorageImageArrayNonUniformIndexingEXT = 5309,
+    InputAttachmentArrayNonUniformIndexing = 5310,
+    InputAttachmentArrayNonUniformIndexingEXT = 5310,
+    UniformTexelBufferArrayNonUniformIndexing = 5311,
+    UniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+    StorageTexelBufferArrayNonUniformIndexing = 5312,
+    StorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+    RayTracingPositionFetchKHR = 5336,
+    RayTracingNV = 5340,
+    RayTracingMotionBlurNV = 5341,
+    VulkanMemoryModel = 5345,
+    VulkanMemoryModelKHR = 5345,
+    VulkanMemoryModelDeviceScope = 5346,
+    VulkanMemoryModelDeviceScopeKHR = 5346,
+    PhysicalStorageBufferAddresses = 5347,
+    PhysicalStorageBufferAddressesEXT = 5347,
+    ComputeDerivativeGroupLinearKHR = 5350,
+    ComputeDerivativeGroupLinearNV = 5350,
+    RayTracingProvisionalKHR = 5353,
+    CooperativeMatrixNV = 5357,
+    FragmentShaderSampleInterlockEXT = 5363,
+    FragmentShaderShadingRateInterlockEXT = 5372,
+    ShaderSMBuiltinsNV = 5373,
+    FragmentShaderPixelInterlockEXT = 5378,
+    DemoteToHelperInvocation = 5379,
+    DemoteToHelperInvocationEXT = 5379,
+    DisplacementMicromapNV = 5380,
+    RayTracingOpacityMicromapEXT = 5381,
+    ShaderInvocationReorderNV = 5383,
+    BindlessTextureNV = 5390,
+    RayQueryPositionFetchKHR = 5391,
+    CooperativeVectorNV = 5394,
+    AtomicFloat16VectorNV = 5404,
+    RayTracingDisplacementMicromapNV = 5409,
+    RawAccessChainsNV = 5414,
+    RayTracingSpheresGeometryNV = 5418,
+    RayTracingLinearSweptSpheresGeometryNV = 5419,
+    CooperativeMatrixReductionsNV = 5430,
+    CooperativeMatrixConversionsNV = 5431,
+    CooperativeMatrixPerElementOperationsNV = 5432,
+    CooperativeMatrixTensorAddressingNV = 5433,
+    CooperativeMatrixBlockLoadsNV = 5434,
+    CooperativeVectorTrainingNV = 5435,
+    RayTracingClusterAccelerationStructureNV = 5437,
+    TensorAddressingNV = 5439,
+    SubgroupShuffleINTEL = 5568,
+    SubgroupBufferBlockIOINTEL = 5569,
+    SubgroupImageBlockIOINTEL = 5570,
+    SubgroupImageMediaBlockIOINTEL = 5579,
+    RoundToInfinityINTEL = 5582,
+    FloatingPointModeINTEL = 5583,
+    IntegerFunctions2INTEL = 5584,
+    FunctionPointersINTEL = 5603,
+    IndirectReferencesINTEL = 5604,
+    AsmINTEL = 5606,
+    AtomicFloat32MinMaxEXT = 5612,
+    AtomicFloat64MinMaxEXT = 5613,
+    AtomicFloat16MinMaxEXT = 5616,
+    VectorComputeINTEL = 5617,
+    VectorAnyINTEL = 5619,
+    ExpectAssumeKHR = 5629,
+    SubgroupAvcMotionEstimationINTEL = 5696,
+    SubgroupAvcMotionEstimationIntraINTEL = 5697,
+    SubgroupAvcMotionEstimationChromaINTEL = 5698,
+    VariableLengthArrayINTEL = 5817,
+    FunctionFloatControlINTEL = 5821,
+    FPGAMemoryAttributesINTEL = 5824,
+    FPFastMathModeINTEL = 5837,
+    ArbitraryPrecisionIntegersINTEL = 5844,
+    ArbitraryPrecisionFloatingPointINTEL = 5845,
+    UnstructuredLoopControlsINTEL = 5886,
+    FPGALoopControlsINTEL = 5888,
+    KernelAttributesINTEL = 5892,
+    FPGAKernelAttributesINTEL = 5897,
+    FPGAMemoryAccessesINTEL = 5898,
+    FPGAClusterAttributesINTEL = 5904,
+    LoopFuseINTEL = 5906,
+    FPGADSPControlINTEL = 5908,
+    MemoryAccessAliasingINTEL = 5910,
+    FPGAInvocationPipeliningAttributesINTEL = 5916,
+    FPGABufferLocationINTEL = 5920,
+    ArbitraryPrecisionFixedPointINTEL = 5922,
+    USMStorageClassesINTEL = 5935,
+    RuntimeAlignedAttributeINTEL = 5939,
+    IOPipesINTEL = 5943,
+    BlockingPipesINTEL = 5945,
+    FPGARegINTEL = 5948,
+    DotProductInputAll = 6016,
+    DotProductInputAllKHR = 6016,
+    DotProductInput4x8Bit = 6017,
+    DotProductInput4x8BitKHR = 6017,
+    DotProductInput4x8BitPacked = 6018,
+    DotProductInput4x8BitPackedKHR = 6018,
+    DotProduct = 6019,
+    DotProductKHR = 6019,
+    RayCullMaskKHR = 6020,
+    CooperativeMatrixKHR = 6022,
+    ReplicatedCompositesEXT = 6024,
+    BitInstructions = 6025,
+    GroupNonUniformRotateKHR = 6026,
+    FloatControls2 = 6029,
+    AtomicFloat32AddEXT = 6033,
+    AtomicFloat64AddEXT = 6034,
+    LongCompositesINTEL = 6089,
+    OptNoneEXT = 6094,
+    OptNoneINTEL = 6094,
+    AtomicFloat16AddEXT = 6095,
+    DebugInfoModuleINTEL = 6114,
+    BFloat16ConversionINTEL = 6115,
+    SplitBarrierINTEL = 6141,
+    ArithmeticFenceEXT = 6144,
+    FPGAClusterAttributesV2INTEL = 6150,
+    FPGAKernelAttributesv2INTEL = 6161,
+    FPMaxErrorINTEL = 6169,
+    FPGALatencyControlINTEL = 6171,
+    FPGAArgumentInterfacesINTEL = 6174,
+    GlobalVariableHostAccessINTEL = 6187,
+    GlobalVariableFPGADecorationsINTEL = 6189,
+    SubgroupBufferPrefetchINTEL = 6220,
+    Subgroup2DBlockIOINTEL = 6228,
+    Subgroup2DBlockTransformINTEL = 6229,
+    Subgroup2DBlockTransposeINTEL = 6230,
+    SubgroupMatrixMultiplyAccumulateINTEL = 6236,
+    GroupUniformArithmeticKHR = 6400,
+    MaskedGatherScatterINTEL = 6427,
+    CacheControlsINTEL = 6441,
+    RegisterLimitsINTEL = 6460,
+    Max = 0x7fffffff,
+};
+
+enum class RayFlagsShift : unsigned {
+    OpaqueKHR = 0,
+    NoOpaqueKHR = 1,
+    TerminateOnFirstHitKHR = 2,
+    SkipClosestHitShaderKHR = 3,
+    CullBackFacingTrianglesKHR = 4,
+    CullFrontFacingTrianglesKHR = 5,
+    CullOpaqueKHR = 6,
+    CullNoOpaqueKHR = 7,
+    SkipBuiltinPrimitivesNV = 8,
+    SkipTrianglesKHR = 8,
+    SkipAABBsKHR = 9,
+    ForceOpacityMicromap2StateEXT = 10,
+    Max = 0x7fffffff,
+};
+
+enum class RayFlagsMask : unsigned {
+    MaskNone = 0,
+    OpaqueKHR = 0x00000001,
+    NoOpaqueKHR = 0x00000002,
+    TerminateOnFirstHitKHR = 0x00000004,
+    SkipClosestHitShaderKHR = 0x00000008,
+    CullBackFacingTrianglesKHR = 0x00000010,
+    CullFrontFacingTrianglesKHR = 0x00000020,
+    CullOpaqueKHR = 0x00000040,
+    CullNoOpaqueKHR = 0x00000080,
+    SkipBuiltinPrimitivesNV = 0x00000100,
+    SkipTrianglesKHR = 0x00000100,
+    SkipAABBsKHR = 0x00000200,
+    ForceOpacityMicromap2StateEXT = 0x00000400,
+};
+
+enum class RayQueryIntersection : unsigned {
+    RayQueryCandidateIntersectionKHR = 0,
+    RayQueryCommittedIntersectionKHR = 1,
+    Max = 0x7fffffff,
+};
+
+enum class RayQueryCommittedIntersectionType : unsigned {
+    RayQueryCommittedIntersectionNoneKHR = 0,
+    RayQueryCommittedIntersectionTriangleKHR = 1,
+    RayQueryCommittedIntersectionGeneratedKHR = 2,
+    Max = 0x7fffffff,
+};
+
+enum class RayQueryCandidateIntersectionType : unsigned {
+    RayQueryCandidateIntersectionTriangleKHR = 0,
+    RayQueryCandidateIntersectionAABBKHR = 1,
+    Max = 0x7fffffff,
+};
+
+enum class FragmentShadingRateShift : unsigned {
+    Vertical2Pixels = 0,
+    Vertical4Pixels = 1,
+    Horizontal2Pixels = 2,
+    Horizontal4Pixels = 3,
+    Max = 0x7fffffff,
+};
+
+enum class FragmentShadingRateMask : unsigned {
+    MaskNone = 0,
+    Vertical2Pixels = 0x00000001,
+    Vertical4Pixels = 0x00000002,
+    Horizontal2Pixels = 0x00000004,
+    Horizontal4Pixels = 0x00000008,
+};
+
+enum class FPDenormMode : unsigned {
+    Preserve = 0,
+    FlushToZero = 1,
+    Max = 0x7fffffff,
+};
+
+enum class FPOperationMode : unsigned {
+    IEEE = 0,
+    ALT = 1,
+    Max = 0x7fffffff,
+};
+
+enum class QuantizationModes : unsigned {
+    TRN = 0,
+    TRN_ZERO = 1,
+    RND = 2,
+    RND_ZERO = 3,
+    RND_INF = 4,
+    RND_MIN_INF = 5,
+    RND_CONV = 6,
+    RND_CONV_ODD = 7,
+    Max = 0x7fffffff,
+};
+
+enum class OverflowModes : unsigned {
+    WRAP = 0,
+    SAT = 1,
+    SAT_ZERO = 2,
+    SAT_SYM = 3,
+    Max = 0x7fffffff,
+};
+
+enum class PackedVectorFormat : unsigned {
+    PackedVectorFormat4x8Bit = 0,
+    PackedVectorFormat4x8BitKHR = 0,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixOperandsShift : unsigned {
+    MatrixASignedComponentsKHR = 0,
+    MatrixBSignedComponentsKHR = 1,
+    MatrixCSignedComponentsKHR = 2,
+    MatrixResultSignedComponentsKHR = 3,
+    SaturatingAccumulationKHR = 4,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixOperandsMask : unsigned {
+    MaskNone = 0,
+    MatrixASignedComponentsKHR = 0x00000001,
+    MatrixBSignedComponentsKHR = 0x00000002,
+    MatrixCSignedComponentsKHR = 0x00000004,
+    MatrixResultSignedComponentsKHR = 0x00000008,
+    SaturatingAccumulationKHR = 0x00000010,
+};
+
+enum class CooperativeMatrixLayout : unsigned {
+    RowMajorKHR = 0,
+    ColumnMajorKHR = 1,
+    RowBlockedInterleavedARM = 4202,
+    ColumnBlockedInterleavedARM = 4203,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixUse : unsigned {
+    MatrixAKHR = 0,
+    MatrixBKHR = 1,
+    MatrixAccumulatorKHR = 2,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixReduceShift : unsigned {
+    Row = 0,
+    Column = 1,
+    CooperativeMatrixReduce2x2 = 2,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeMatrixReduceMask : unsigned {
+    MaskNone = 0,
+    Row = 0x00000001,
+    Column = 0x00000002,
+    CooperativeMatrixReduce2x2 = 0x00000004,
+};
+
+enum class TensorClampMode : unsigned {
+    Undefined = 0,
+    Constant = 1,
+    ClampToEdge = 2,
+    Repeat = 3,
+    RepeatMirrored = 4,
+    Max = 0x7fffffff,
+};
+
+enum class TensorAddressingOperandsShift : unsigned {
+    TensorView = 0,
+    DecodeFunc = 1,
+    Max = 0x7fffffff,
+};
+
+enum class TensorAddressingOperandsMask : unsigned {
+    MaskNone = 0,
+    TensorView = 0x00000001,
+    DecodeFunc = 0x00000002,
+};
+
+enum class InitializationModeQualifier : unsigned {
+    InitOnDeviceReprogramINTEL = 0,
+    InitOnDeviceResetINTEL = 1,
+    Max = 0x7fffffff,
+};
+
+enum class HostAccessQualifier : unsigned {
+    NoneINTEL = 0,
+    ReadINTEL = 1,
+    WriteINTEL = 2,
+    ReadWriteINTEL = 3,
+    Max = 0x7fffffff,
+};
+
+enum class LoadCacheControl : unsigned {
+    UncachedINTEL = 0,
+    CachedINTEL = 1,
+    StreamingINTEL = 2,
+    InvalidateAfterReadINTEL = 3,
+    ConstCachedINTEL = 4,
+    Max = 0x7fffffff,
+};
+
+enum class StoreCacheControl : unsigned {
+    UncachedINTEL = 0,
+    WriteThroughINTEL = 1,
+    WriteBackINTEL = 2,
+    StreamingINTEL = 3,
+    Max = 0x7fffffff,
+};
+
+enum class NamedMaximumNumberOfRegisters : unsigned {
+    AutoINTEL = 0,
+    Max = 0x7fffffff,
+};
+
+enum class MatrixMultiplyAccumulateOperandsShift : unsigned {
+    MatrixASignedComponentsINTEL = 0,
+    MatrixBSignedComponentsINTEL = 1,
+    MatrixCBFloat16INTEL = 2,
+    MatrixResultBFloat16INTEL = 3,
+    MatrixAPackedInt8INTEL = 4,
+    MatrixBPackedInt8INTEL = 5,
+    MatrixAPackedInt4INTEL = 6,
+    MatrixBPackedInt4INTEL = 7,
+    MatrixATF32INTEL = 8,
+    MatrixBTF32INTEL = 9,
+    MatrixAPackedFloat16INTEL = 10,
+    MatrixBPackedFloat16INTEL = 11,
+    MatrixAPackedBFloat16INTEL = 12,
+    MatrixBPackedBFloat16INTEL = 13,
+    Max = 0x7fffffff,
+};
+
+enum class MatrixMultiplyAccumulateOperandsMask : unsigned {
+    MaskNone = 0,
+    MatrixASignedComponentsINTEL = 0x00000001,
+    MatrixBSignedComponentsINTEL = 0x00000002,
+    MatrixCBFloat16INTEL = 0x00000004,
+    MatrixResultBFloat16INTEL = 0x00000008,
+    MatrixAPackedInt8INTEL = 0x00000010,
+    MatrixBPackedInt8INTEL = 0x00000020,
+    MatrixAPackedInt4INTEL = 0x00000040,
+    MatrixBPackedInt4INTEL = 0x00000080,
+    MatrixATF32INTEL = 0x00000100,
+    MatrixBTF32INTEL = 0x00000200,
+    MatrixAPackedFloat16INTEL = 0x00000400,
+    MatrixBPackedFloat16INTEL = 0x00000800,
+    MatrixAPackedBFloat16INTEL = 0x00001000,
+    MatrixBPackedBFloat16INTEL = 0x00002000,
+};
+
+enum class RawAccessChainOperandsShift : unsigned {
+    RobustnessPerComponentNV = 0,
+    RobustnessPerElementNV = 1,
+    Max = 0x7fffffff,
+};
+
+enum class RawAccessChainOperandsMask : unsigned {
+    MaskNone = 0,
+    RobustnessPerComponentNV = 0x00000001,
+    RobustnessPerElementNV = 0x00000002,
+};
+
+enum class FPEncoding : unsigned {
+    BFloat16KHR = 0,
+    Float8E4M3EXT = 4214,
+    Float8E5M2EXT = 4215,
+    Max = 0x7fffffff,
+};
+
+enum class CooperativeVectorMatrixLayout : unsigned {
+    RowMajorNV = 0,
+    ColumnMajorNV = 1,
+    InferencingOptimalNV = 2,
+    TrainingOptimalNV = 3,
+    Max = 0x7fffffff,
+};
+
+enum class ComponentType : unsigned {
+    Float16NV = 0,
+    Float32NV = 1,
+    Float64NV = 2,
+    SignedInt8NV = 3,
+    SignedInt16NV = 4,
+    SignedInt32NV = 5,
+    SignedInt64NV = 6,
+    UnsignedInt8NV = 7,
+    UnsignedInt16NV = 8,
+    UnsignedInt32NV = 9,
+    UnsignedInt64NV = 10,
+    SignedInt8PackedNV = 1000491000,
+    UnsignedInt8PackedNV = 1000491001,
+    FloatE4M3NV = 1000491002,
+    FloatE5M2NV = 1000491003,
+    Max = 0x7fffffff,
+};
+
+enum class Op : unsigned {
+    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,
+    OpColorAttachmentReadEXT = 4160,
+    OpDepthAttachmentReadEXT = 4161,
+    OpStencilAttachmentReadEXT = 4162,
+    OpTerminateInvocation = 4416,
+    OpTypeUntypedPointerKHR = 4417,
+    OpUntypedVariableKHR = 4418,
+    OpUntypedAccessChainKHR = 4419,
+    OpUntypedInBoundsAccessChainKHR = 4420,
+    OpSubgroupBallotKHR = 4421,
+    OpSubgroupFirstInvocationKHR = 4422,
+    OpUntypedPtrAccessChainKHR = 4423,
+    OpUntypedInBoundsPtrAccessChainKHR = 4424,
+    OpUntypedArrayLengthKHR = 4425,
+    OpUntypedPrefetchKHR = 4426,
+    OpSubgroupAllKHR = 4428,
+    OpSubgroupAnyKHR = 4429,
+    OpSubgroupAllEqualKHR = 4430,
+    OpGroupNonUniformRotateKHR = 4431,
+    OpSubgroupReadInvocationKHR = 4432,
+    OpExtInstWithForwardRefsKHR = 4433,
+    OpTraceRayKHR = 4445,
+    OpExecuteCallableKHR = 4446,
+    OpConvertUToAccelerationStructureKHR = 4447,
+    OpIgnoreIntersectionKHR = 4448,
+    OpTerminateRayKHR = 4449,
+    OpSDot = 4450,
+    OpSDotKHR = 4450,
+    OpUDot = 4451,
+    OpUDotKHR = 4451,
+    OpSUDot = 4452,
+    OpSUDotKHR = 4452,
+    OpSDotAccSat = 4453,
+    OpSDotAccSatKHR = 4453,
+    OpUDotAccSat = 4454,
+    OpUDotAccSatKHR = 4454,
+    OpSUDotAccSat = 4455,
+    OpSUDotAccSatKHR = 4455,
+    OpTypeCooperativeMatrixKHR = 4456,
+    OpCooperativeMatrixLoadKHR = 4457,
+    OpCooperativeMatrixStoreKHR = 4458,
+    OpCooperativeMatrixMulAddKHR = 4459,
+    OpCooperativeMatrixLengthKHR = 4460,
+    OpConstantCompositeReplicateEXT = 4461,
+    OpSpecConstantCompositeReplicateEXT = 4462,
+    OpCompositeConstructReplicateEXT = 4463,
+    OpTypeRayQueryKHR = 4472,
+    OpRayQueryInitializeKHR = 4473,
+    OpRayQueryTerminateKHR = 4474,
+    OpRayQueryGenerateIntersectionKHR = 4475,
+    OpRayQueryConfirmIntersectionKHR = 4476,
+    OpRayQueryProceedKHR = 4477,
+    OpRayQueryGetIntersectionTypeKHR = 4479,
+    OpImageSampleWeightedQCOM = 4480,
+    OpImageBoxFilterQCOM = 4481,
+    OpImageBlockMatchSSDQCOM = 4482,
+    OpImageBlockMatchSADQCOM = 4483,
+    OpImageBlockMatchWindowSSDQCOM = 4500,
+    OpImageBlockMatchWindowSADQCOM = 4501,
+    OpImageBlockMatchGatherSSDQCOM = 4502,
+    OpImageBlockMatchGatherSADQCOM = 4503,
+    OpGroupIAddNonUniformAMD = 5000,
+    OpGroupFAddNonUniformAMD = 5001,
+    OpGroupFMinNonUniformAMD = 5002,
+    OpGroupUMinNonUniformAMD = 5003,
+    OpGroupSMinNonUniformAMD = 5004,
+    OpGroupFMaxNonUniformAMD = 5005,
+    OpGroupUMaxNonUniformAMD = 5006,
+    OpGroupSMaxNonUniformAMD = 5007,
+    OpFragmentMaskFetchAMD = 5011,
+    OpFragmentFetchAMD = 5012,
+    OpReadClockKHR = 5056,
+    OpAllocateNodePayloadsAMDX = 5074,
+    OpEnqueueNodePayloadsAMDX = 5075,
+    OpTypeNodePayloadArrayAMDX = 5076,
+    OpFinishWritingNodePayloadAMDX = 5078,
+    OpNodePayloadArrayLengthAMDX = 5090,
+    OpIsNodePayloadValidAMDX = 5101,
+    OpConstantStringAMDX = 5103,
+    OpSpecConstantStringAMDX = 5104,
+    OpGroupNonUniformQuadAllKHR = 5110,
+    OpGroupNonUniformQuadAnyKHR = 5111,
+    OpHitObjectRecordHitMotionNV = 5249,
+    OpHitObjectRecordHitWithIndexMotionNV = 5250,
+    OpHitObjectRecordMissMotionNV = 5251,
+    OpHitObjectGetWorldToObjectNV = 5252,
+    OpHitObjectGetObjectToWorldNV = 5253,
+    OpHitObjectGetObjectRayDirectionNV = 5254,
+    OpHitObjectGetObjectRayOriginNV = 5255,
+    OpHitObjectTraceRayMotionNV = 5256,
+    OpHitObjectGetShaderRecordBufferHandleNV = 5257,
+    OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
+    OpHitObjectRecordEmptyNV = 5259,
+    OpHitObjectTraceRayNV = 5260,
+    OpHitObjectRecordHitNV = 5261,
+    OpHitObjectRecordHitWithIndexNV = 5262,
+    OpHitObjectRecordMissNV = 5263,
+    OpHitObjectExecuteShaderNV = 5264,
+    OpHitObjectGetCurrentTimeNV = 5265,
+    OpHitObjectGetAttributesNV = 5266,
+    OpHitObjectGetHitKindNV = 5267,
+    OpHitObjectGetPrimitiveIndexNV = 5268,
+    OpHitObjectGetGeometryIndexNV = 5269,
+    OpHitObjectGetInstanceIdNV = 5270,
+    OpHitObjectGetInstanceCustomIndexNV = 5271,
+    OpHitObjectGetWorldRayDirectionNV = 5272,
+    OpHitObjectGetWorldRayOriginNV = 5273,
+    OpHitObjectGetRayTMaxNV = 5274,
+    OpHitObjectGetRayTMinNV = 5275,
+    OpHitObjectIsEmptyNV = 5276,
+    OpHitObjectIsHitNV = 5277,
+    OpHitObjectIsMissNV = 5278,
+    OpReorderThreadWithHitObjectNV = 5279,
+    OpReorderThreadWithHintNV = 5280,
+    OpTypeHitObjectNV = 5281,
+    OpImageSampleFootprintNV = 5283,
+    OpTypeCooperativeVectorNV = 5288,
+    OpCooperativeVectorMatrixMulNV = 5289,
+    OpCooperativeVectorOuterProductAccumulateNV = 5290,
+    OpCooperativeVectorReduceSumAccumulateNV = 5291,
+    OpCooperativeVectorMatrixMulAddNV = 5292,
+    OpCooperativeMatrixConvertNV = 5293,
+    OpEmitMeshTasksEXT = 5294,
+    OpSetMeshOutputsEXT = 5295,
+    OpGroupNonUniformPartitionNV = 5296,
+    OpWritePackedPrimitiveIndices4x8NV = 5299,
+    OpFetchMicroTriangleVertexPositionNV = 5300,
+    OpFetchMicroTriangleVertexBarycentricNV = 5301,
+    OpCooperativeVectorLoadNV = 5302,
+    OpCooperativeVectorStoreNV = 5303,
+    OpReportIntersectionKHR = 5334,
+    OpReportIntersectionNV = 5334,
+    OpIgnoreIntersectionNV = 5335,
+    OpTerminateRayNV = 5336,
+    OpTraceNV = 5337,
+    OpTraceMotionNV = 5338,
+    OpTraceRayMotionNV = 5339,
+    OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
+    OpTypeAccelerationStructureKHR = 5341,
+    OpTypeAccelerationStructureNV = 5341,
+    OpExecuteCallableNV = 5344,
+    OpRayQueryGetClusterIdNV = 5345,
+    OpHitObjectGetClusterIdNV = 5346,
+    OpTypeCooperativeMatrixNV = 5358,
+    OpCooperativeMatrixLoadNV = 5359,
+    OpCooperativeMatrixStoreNV = 5360,
+    OpCooperativeMatrixMulAddNV = 5361,
+    OpCooperativeMatrixLengthNV = 5362,
+    OpBeginInvocationInterlockEXT = 5364,
+    OpEndInvocationInterlockEXT = 5365,
+    OpCooperativeMatrixReduceNV = 5366,
+    OpCooperativeMatrixLoadTensorNV = 5367,
+    OpCooperativeMatrixStoreTensorNV = 5368,
+    OpCooperativeMatrixPerElementOpNV = 5369,
+    OpTypeTensorLayoutNV = 5370,
+    OpTypeTensorViewNV = 5371,
+    OpCreateTensorLayoutNV = 5372,
+    OpTensorLayoutSetDimensionNV = 5373,
+    OpTensorLayoutSetStrideNV = 5374,
+    OpTensorLayoutSliceNV = 5375,
+    OpTensorLayoutSetClampValueNV = 5376,
+    OpCreateTensorViewNV = 5377,
+    OpTensorViewSetDimensionNV = 5378,
+    OpTensorViewSetStrideNV = 5379,
+    OpDemoteToHelperInvocation = 5380,
+    OpDemoteToHelperInvocationEXT = 5380,
+    OpIsHelperInvocationEXT = 5381,
+    OpTensorViewSetClipNV = 5382,
+    OpTensorLayoutSetBlockSizeNV = 5384,
+    OpCooperativeMatrixTransposeNV = 5390,
+    OpConvertUToImageNV = 5391,
+    OpConvertUToSamplerNV = 5392,
+    OpConvertImageToUNV = 5393,
+    OpConvertSamplerToUNV = 5394,
+    OpConvertUToSampledImageNV = 5395,
+    OpConvertSampledImageToUNV = 5396,
+    OpSamplerImageAddressingModeNV = 5397,
+    OpRawAccessChainNV = 5398,
+    OpRayQueryGetIntersectionSpherePositionNV = 5427,
+    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+    OpHitObjectGetSpherePositionNV = 5432,
+    OpHitObjectGetSphereRadiusNV = 5433,
+    OpHitObjectGetLSSPositionsNV = 5434,
+    OpHitObjectGetLSSRadiiNV = 5435,
+    OpHitObjectIsSphereHitNV = 5436,
+    OpHitObjectIsLSSHitNV = 5437,
+    OpRayQueryIsSphereHitNV = 5438,
+    OpRayQueryIsLSSHitNV = 5439,
+    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,
+    OpConstantFunctionPointerINTEL = 5600,
+    OpFunctionPointerCallINTEL = 5601,
+    OpAsmTargetINTEL = 5609,
+    OpAsmINTEL = 5610,
+    OpAsmCallINTEL = 5611,
+    OpAtomicFMinEXT = 5614,
+    OpAtomicFMaxEXT = 5615,
+    OpAssumeTrueKHR = 5630,
+    OpExpectKHR = 5631,
+    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,
+    OpVariableLengthArrayINTEL = 5818,
+    OpSaveMemoryINTEL = 5819,
+    OpRestoreMemoryINTEL = 5820,
+    OpArbitraryFloatSinCosPiINTEL = 5840,
+    OpArbitraryFloatCastINTEL = 5841,
+    OpArbitraryFloatCastFromIntINTEL = 5842,
+    OpArbitraryFloatCastToIntINTEL = 5843,
+    OpArbitraryFloatAddINTEL = 5846,
+    OpArbitraryFloatSubINTEL = 5847,
+    OpArbitraryFloatMulINTEL = 5848,
+    OpArbitraryFloatDivINTEL = 5849,
+    OpArbitraryFloatGTINTEL = 5850,
+    OpArbitraryFloatGEINTEL = 5851,
+    OpArbitraryFloatLTINTEL = 5852,
+    OpArbitraryFloatLEINTEL = 5853,
+    OpArbitraryFloatEQINTEL = 5854,
+    OpArbitraryFloatRecipINTEL = 5855,
+    OpArbitraryFloatRSqrtINTEL = 5856,
+    OpArbitraryFloatCbrtINTEL = 5857,
+    OpArbitraryFloatHypotINTEL = 5858,
+    OpArbitraryFloatSqrtINTEL = 5859,
+    OpArbitraryFloatLogINTEL = 5860,
+    OpArbitraryFloatLog2INTEL = 5861,
+    OpArbitraryFloatLog10INTEL = 5862,
+    OpArbitraryFloatLog1pINTEL = 5863,
+    OpArbitraryFloatExpINTEL = 5864,
+    OpArbitraryFloatExp2INTEL = 5865,
+    OpArbitraryFloatExp10INTEL = 5866,
+    OpArbitraryFloatExpm1INTEL = 5867,
+    OpArbitraryFloatSinINTEL = 5868,
+    OpArbitraryFloatCosINTEL = 5869,
+    OpArbitraryFloatSinCosINTEL = 5870,
+    OpArbitraryFloatSinPiINTEL = 5871,
+    OpArbitraryFloatCosPiINTEL = 5872,
+    OpArbitraryFloatASinINTEL = 5873,
+    OpArbitraryFloatASinPiINTEL = 5874,
+    OpArbitraryFloatACosINTEL = 5875,
+    OpArbitraryFloatACosPiINTEL = 5876,
+    OpArbitraryFloatATanINTEL = 5877,
+    OpArbitraryFloatATanPiINTEL = 5878,
+    OpArbitraryFloatATan2INTEL = 5879,
+    OpArbitraryFloatPowINTEL = 5880,
+    OpArbitraryFloatPowRINTEL = 5881,
+    OpArbitraryFloatPowNINTEL = 5882,
+    OpLoopControlINTEL = 5887,
+    OpAliasDomainDeclINTEL = 5911,
+    OpAliasScopeDeclINTEL = 5912,
+    OpAliasScopeListDeclINTEL = 5913,
+    OpFixedSqrtINTEL = 5923,
+    OpFixedRecipINTEL = 5924,
+    OpFixedRsqrtINTEL = 5925,
+    OpFixedSinINTEL = 5926,
+    OpFixedCosINTEL = 5927,
+    OpFixedSinCosINTEL = 5928,
+    OpFixedSinPiINTEL = 5929,
+    OpFixedCosPiINTEL = 5930,
+    OpFixedSinCosPiINTEL = 5931,
+    OpFixedLogINTEL = 5932,
+    OpFixedExpINTEL = 5933,
+    OpPtrCastToCrossWorkgroupINTEL = 5934,
+    OpCrossWorkgroupCastToPtrINTEL = 5938,
+    OpReadPipeBlockingINTEL = 5946,
+    OpWritePipeBlockingINTEL = 5947,
+    OpFPGARegINTEL = 5949,
+    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,
+    OpAtomicFAddEXT = 6035,
+    OpTypeBufferSurfaceINTEL = 6086,
+    OpTypeStructContinuedINTEL = 6090,
+    OpConstantCompositeContinuedINTEL = 6091,
+    OpSpecConstantCompositeContinuedINTEL = 6092,
+    OpCompositeConstructContinuedINTEL = 6096,
+    OpConvertFToBF16INTEL = 6116,
+    OpConvertBF16ToFINTEL = 6117,
+    OpControlBarrierArriveINTEL = 6142,
+    OpControlBarrierWaitINTEL = 6143,
+    OpArithmeticFenceEXT = 6145,
+    OpSubgroupBlockPrefetchINTEL = 6221,
+    OpSubgroup2DBlockLoadINTEL = 6231,
+    OpSubgroup2DBlockLoadTransformINTEL = 6232,
+    OpSubgroup2DBlockLoadTransposeINTEL = 6233,
+    OpSubgroup2DBlockPrefetchINTEL = 6234,
+    OpSubgroup2DBlockStoreINTEL = 6235,
+    OpSubgroupMatrixMultiplyAccumulateINTEL = 6237,
+    OpGroupIMulKHR = 6401,
+    OpGroupFMulKHR = 6402,
+    OpGroupBitwiseAndKHR = 6403,
+    OpGroupBitwiseOrKHR = 6404,
+    OpGroupBitwiseXorKHR = 6405,
+    OpGroupLogicalAndKHR = 6406,
+    OpGroupLogicalOrKHR = 6407,
+    OpGroupLogicalXorKHR = 6408,
+    OpMaskedGatherINTEL = 6428,
+    OpMaskedScatterINTEL = 6429,
+    Max = 0x7fffffff,
+};
+
+#ifdef SPV_ENABLE_UTILITY_CODE
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
+    *hasResult = *hasResultType = false;
+    switch (opcode) {
+    default: /* unknown opcode */ break;
+    case Op::OpNop: *hasResult = false; *hasResultType = false; break;
+    case Op::OpUndef: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSourceContinued: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSource: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSourceExtension: *hasResult = false; *hasResultType = false; break;
+    case Op::OpName: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemberName: *hasResult = false; *hasResultType = false; break;
+    case Op::OpString: *hasResult = true; *hasResultType = false; break;
+    case Op::OpLine: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExtension: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExtInstImport: *hasResult = true; *hasResultType = false; break;
+    case Op::OpExtInst: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMemoryModel: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEntryPoint: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExecutionMode: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCapability: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeVoid: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeBool: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeInt: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeFloat: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeVector: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeImage: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeSampler: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeArray: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeStruct: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypePointer: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeFunction: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeEvent: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeQueue: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypePipe: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstant: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantSampler: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantNull: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstant: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunction: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
+    case Op::OpFunctionCall: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVariable: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLoad: *hasResult = true; *hasResultType = true; break;
+    case Op::OpStore: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCopyMemory: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArrayLength: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
+    case Op::OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
+    case Op::OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
+    case Op::OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCopyObject: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTranspose: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSampledImage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageFetch: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageRead: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageWrite: *hasResult = false; *hasResultType = false; break;
+    case Op::OpImage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertFToU: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertFToS: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertSToF: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToF: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUConvert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSConvert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFConvert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSNegate: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFNegate: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpISub: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFSub: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUDiv: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSDiv: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFDiv: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUMod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSRem: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSMod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFRem: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFMod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
+    case Op::OpOuterProduct: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAddCarry: *hasResult = true; *hasResultType = true; break;
+    case Op::OpISubBorrow: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUMulExtended: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSMulExtended: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAny: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAll: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsNan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsInf: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsFinite: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsNormal: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSignBitSet: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
+    case Op::OpOrdered: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUnordered: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLogicalNot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSelect: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpINotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpULessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSLessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
+    case Op::OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
+    case Op::OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpNot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitReverse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBitCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdx: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdy: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFwidth: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdxFine: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdyFine: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFwidthFine: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEmitVertex: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
+    case Op::OpControlBarrier: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicStore: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicISub: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPhi: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLoopMerge: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
+    case Op::OpLabel: *hasResult = true; *hasResultType = false; break;
+    case Op::OpBranch: *hasResult = false; *hasResultType = false; break;
+    case Op::OpBranchConditional: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSwitch: *hasResult = false; *hasResultType = false; break;
+    case Op::OpKill: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReturn: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReturnValue: *hasResult = false; *hasResultType = false; break;
+    case Op::OpUnreachable: *hasResult = false; *hasResultType = false; break;
+    case Op::OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
+    case Op::OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupAll: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupAny: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReadPipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpWritePipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRetainEvent: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
+    case Op::OpNoLine: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
+    case Op::OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSizeOf: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
+    case Op::OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
+    case Op::OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
+    case Op::OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
+    case Op::OpDecorateId: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCopyLogical: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrDiff: *hasResult = true; *hasResultType = true; break;
+    case Op::OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeUntypedPointerKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpUntypedVariableKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedInBoundsAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedInBoundsPtrAccessChainKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedArrayLengthKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUntypedPrefetchKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpExtInstWithForwardRefsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSUDot: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSDotAccSat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUDotAccSat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeCooperativeMatrixKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixLoadKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSpecConstantCompositeReplicateEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCompositeConstructReplicateEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageSampleWeightedQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBoxFilterQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchSSDQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchWindowSSDQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchWindowSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchGatherSSDQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpImageBlockMatchGatherSADQCOM: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAllocateNodePayloadsAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEnqueueNodePayloadsAMDX: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeNodePayloadArrayAMDX: *hasResult = true; *hasResultType = false; break;
+    case Op::OpFinishWritingNodePayloadAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpNodePayloadArrayLengthAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIsNodePayloadValidAMDX: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
+    case Op::OpSpecConstantStringAMDX: *hasResult = true; *hasResultType = false; break;
+    case Op::OpGroupNonUniformQuadAllKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupNonUniformQuadAnyKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetWorldToObjectNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetObjectToWorldNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetObjectRayDirectionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetObjectRayOriginNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetShaderRecordBufferHandleNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetShaderBindingTableRecordIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectRecordEmptyNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectTraceRayNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordHitNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordHitWithIndexNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectRecordMissNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectExecuteShaderNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetCurrentTimeNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetAttributesNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpHitObjectGetHitKindNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetPrimitiveIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetGeometryIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetInstanceIdNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetInstanceCustomIndexNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetWorldRayDirectionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetWorldRayOriginNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetRayTMaxNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetRayTMinNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReorderThreadWithHitObjectNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTraceNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeAccelerationStructureKHR: *hasResult = true; *hasResultType = false; break;
+    case Op::OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRayQueryGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetClusterIdNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixReduceNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixLoadTensorNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixStoreTensorNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCooperativeMatrixPerElementOpNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeTensorLayoutNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeTensorViewNV: *hasResult = true; *hasResultType = false; break;
+    case Op::OpCreateTensorLayoutNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetStrideNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSliceNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetClampValueNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCreateTensorViewNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorViewSetDimensionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorViewSetStrideNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
+    case Op::OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorViewSetClipNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTensorLayoutSetBlockSizeNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCooperativeMatrixTransposeNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
+    case Op::OpRawAccessChainNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionLSSHitValueNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetSpherePositionNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetSphereRadiusNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetLSSPositionsNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectGetLSSRadiiNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpHitObjectIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryIsSphereHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryIsLSSHitNV: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAsmTargetINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
+    case Op::OpExpectKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpDecorateString: *hasResult = false; *hasResultType = false; break;
+    case Op::OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
+    case Op::OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpAliasDomainDeclINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpAliasScopeDeclINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpAliasScopeListDeclINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
+    case Op::OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpCompositeConstructContinuedINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertFToBF16INTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpConvertBF16ToFINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpArithmeticFenceEXT: *hasResult = true; *hasResultType = true; break;
+    case Op::OpSubgroupBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockLoadINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockLoadTransformINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockLoadTransposeINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockPrefetchINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroup2DBlockStoreINTEL: *hasResult = false; *hasResultType = false; break;
+    case Op::OpSubgroupMatrixMultiplyAccumulateINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBitwiseOrKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupBitwiseXorKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMaskedGatherINTEL: *hasResult = true; *hasResultType = true; break;
+    case Op::OpMaskedScatterINTEL: *hasResult = false; *hasResultType = false; break;
+    }
+}
+inline const char* SourceLanguageToString(SourceLanguage value) {
+    switch (value) {
+    case SourceLanguage::Unknown: return "Unknown";
+    case SourceLanguage::ESSL: return "ESSL";
+    case SourceLanguage::GLSL: return "GLSL";
+    case SourceLanguage::OpenCL_C: return "OpenCL_C";
+    case SourceLanguage::OpenCL_CPP: return "OpenCL_CPP";
+    case SourceLanguage::HLSL: return "HLSL";
+    case SourceLanguage::CPP_for_OpenCL: return "CPP_for_OpenCL";
+    case SourceLanguage::SYCL: return "SYCL";
+    case SourceLanguage::HERO_C: return "HERO_C";
+    case SourceLanguage::NZSL: return "NZSL";
+    case SourceLanguage::WGSL: return "WGSL";
+    case SourceLanguage::Slang: return "Slang";
+    case SourceLanguage::Zig: return "Zig";
+    case SourceLanguage::Rust: return "Rust";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ExecutionModelToString(ExecutionModel value) {
+    switch (value) {
+    case ExecutionModel::Vertex: return "Vertex";
+    case ExecutionModel::TessellationControl: return "TessellationControl";
+    case ExecutionModel::TessellationEvaluation: return "TessellationEvaluation";
+    case ExecutionModel::Geometry: return "Geometry";
+    case ExecutionModel::Fragment: return "Fragment";
+    case ExecutionModel::GLCompute: return "GLCompute";
+    case ExecutionModel::Kernel: return "Kernel";
+    case ExecutionModel::TaskNV: return "TaskNV";
+    case ExecutionModel::MeshNV: return "MeshNV";
+    case ExecutionModel::RayGenerationKHR: return "RayGenerationKHR";
+    case ExecutionModel::IntersectionKHR: return "IntersectionKHR";
+    case ExecutionModel::AnyHitKHR: return "AnyHitKHR";
+    case ExecutionModel::ClosestHitKHR: return "ClosestHitKHR";
+    case ExecutionModel::MissKHR: return "MissKHR";
+    case ExecutionModel::CallableKHR: return "CallableKHR";
+    case ExecutionModel::TaskEXT: return "TaskEXT";
+    case ExecutionModel::MeshEXT: return "MeshEXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* AddressingModelToString(AddressingModel value) {
+    switch (value) {
+    case AddressingModel::Logical: return "Logical";
+    case AddressingModel::Physical32: return "Physical32";
+    case AddressingModel::Physical64: return "Physical64";
+    case AddressingModel::PhysicalStorageBuffer64: return "PhysicalStorageBuffer64";
+    default: return "Unknown";
+    }
+}
+
+inline const char* MemoryModelToString(MemoryModel value) {
+    switch (value) {
+    case MemoryModel::Simple: return "Simple";
+    case MemoryModel::GLSL450: return "GLSL450";
+    case MemoryModel::OpenCL: return "OpenCL";
+    case MemoryModel::Vulkan: return "Vulkan";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ExecutionModeToString(ExecutionMode value) {
+    switch (value) {
+    case ExecutionMode::Invocations: return "Invocations";
+    case ExecutionMode::SpacingEqual: return "SpacingEqual";
+    case ExecutionMode::SpacingFractionalEven: return "SpacingFractionalEven";
+    case ExecutionMode::SpacingFractionalOdd: return "SpacingFractionalOdd";
+    case ExecutionMode::VertexOrderCw: return "VertexOrderCw";
+    case ExecutionMode::VertexOrderCcw: return "VertexOrderCcw";
+    case ExecutionMode::PixelCenterInteger: return "PixelCenterInteger";
+    case ExecutionMode::OriginUpperLeft: return "OriginUpperLeft";
+    case ExecutionMode::OriginLowerLeft: return "OriginLowerLeft";
+    case ExecutionMode::EarlyFragmentTests: return "EarlyFragmentTests";
+    case ExecutionMode::PointMode: return "PointMode";
+    case ExecutionMode::Xfb: return "Xfb";
+    case ExecutionMode::DepthReplacing: return "DepthReplacing";
+    case ExecutionMode::DepthGreater: return "DepthGreater";
+    case ExecutionMode::DepthLess: return "DepthLess";
+    case ExecutionMode::DepthUnchanged: return "DepthUnchanged";
+    case ExecutionMode::LocalSize: return "LocalSize";
+    case ExecutionMode::LocalSizeHint: return "LocalSizeHint";
+    case ExecutionMode::InputPoints: return "InputPoints";
+    case ExecutionMode::InputLines: return "InputLines";
+    case ExecutionMode::InputLinesAdjacency: return "InputLinesAdjacency";
+    case ExecutionMode::Triangles: return "Triangles";
+    case ExecutionMode::InputTrianglesAdjacency: return "InputTrianglesAdjacency";
+    case ExecutionMode::Quads: return "Quads";
+    case ExecutionMode::Isolines: return "Isolines";
+    case ExecutionMode::OutputVertices: return "OutputVertices";
+    case ExecutionMode::OutputPoints: return "OutputPoints";
+    case ExecutionMode::OutputLineStrip: return "OutputLineStrip";
+    case ExecutionMode::OutputTriangleStrip: return "OutputTriangleStrip";
+    case ExecutionMode::VecTypeHint: return "VecTypeHint";
+    case ExecutionMode::ContractionOff: return "ContractionOff";
+    case ExecutionMode::Initializer: return "Initializer";
+    case ExecutionMode::Finalizer: return "Finalizer";
+    case ExecutionMode::SubgroupSize: return "SubgroupSize";
+    case ExecutionMode::SubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup";
+    case ExecutionMode::SubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId";
+    case ExecutionMode::LocalSizeId: return "LocalSizeId";
+    case ExecutionMode::LocalSizeHintId: return "LocalSizeHintId";
+    case ExecutionMode::NonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT";
+    case ExecutionMode::NonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT";
+    case ExecutionMode::NonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT";
+    case ExecutionMode::SubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlowKHR";
+    case ExecutionMode::PostDepthCoverage: return "PostDepthCoverage";
+    case ExecutionMode::DenormPreserve: return "DenormPreserve";
+    case ExecutionMode::DenormFlushToZero: return "DenormFlushToZero";
+    case ExecutionMode::SignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+    case ExecutionMode::RoundingModeRTE: return "RoundingModeRTE";
+    case ExecutionMode::RoundingModeRTZ: return "RoundingModeRTZ";
+    case ExecutionMode::NonCoherentTileAttachmentReadQCOM: return "NonCoherentTileAttachmentReadQCOM";
+    case ExecutionMode::TileShadingRateQCOM: return "TileShadingRateQCOM";
+    case ExecutionMode::EarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
+    case ExecutionMode::StencilRefReplacingEXT: return "StencilRefReplacingEXT";
+    case ExecutionMode::CoalescingAMDX: return "CoalescingAMDX";
+    case ExecutionMode::IsApiEntryAMDX: return "IsApiEntryAMDX";
+    case ExecutionMode::MaxNodeRecursionAMDX: return "MaxNodeRecursionAMDX";
+    case ExecutionMode::StaticNumWorkgroupsAMDX: return "StaticNumWorkgroupsAMDX";
+    case ExecutionMode::ShaderIndexAMDX: return "ShaderIndexAMDX";
+    case ExecutionMode::MaxNumWorkgroupsAMDX: return "MaxNumWorkgroupsAMDX";
+    case ExecutionMode::StencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD";
+    case ExecutionMode::StencilRefGreaterFrontAMD: return "StencilRefGreaterFrontAMD";
+    case ExecutionMode::StencilRefLessFrontAMD: return "StencilRefLessFrontAMD";
+    case ExecutionMode::StencilRefUnchangedBackAMD: return "StencilRefUnchangedBackAMD";
+    case ExecutionMode::StencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD";
+    case ExecutionMode::StencilRefLessBackAMD: return "StencilRefLessBackAMD";
+    case ExecutionMode::QuadDerivativesKHR: return "QuadDerivativesKHR";
+    case ExecutionMode::RequireFullQuadsKHR: return "RequireFullQuadsKHR";
+    case ExecutionMode::SharesInputWithAMDX: return "SharesInputWithAMDX";
+    case ExecutionMode::OutputLinesEXT: return "OutputLinesEXT";
+    case ExecutionMode::OutputPrimitivesEXT: return "OutputPrimitivesEXT";
+    case ExecutionMode::DerivativeGroupQuadsKHR: return "DerivativeGroupQuadsKHR";
+    case ExecutionMode::DerivativeGroupLinearKHR: return "DerivativeGroupLinearKHR";
+    case ExecutionMode::OutputTrianglesEXT: return "OutputTrianglesEXT";
+    case ExecutionMode::PixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT";
+    case ExecutionMode::PixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT";
+    case ExecutionMode::SampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT";
+    case ExecutionMode::SampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT";
+    case ExecutionMode::ShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT";
+    case ExecutionMode::ShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
+    case ExecutionMode::SharedLocalMemorySizeINTEL: return "SharedLocalMemorySizeINTEL";
+    case ExecutionMode::RoundingModeRTPINTEL: return "RoundingModeRTPINTEL";
+    case ExecutionMode::RoundingModeRTNINTEL: return "RoundingModeRTNINTEL";
+    case ExecutionMode::FloatingPointModeALTINTEL: return "FloatingPointModeALTINTEL";
+    case ExecutionMode::FloatingPointModeIEEEINTEL: return "FloatingPointModeIEEEINTEL";
+    case ExecutionMode::MaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL";
+    case ExecutionMode::MaxWorkDimINTEL: return "MaxWorkDimINTEL";
+    case ExecutionMode::NoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL";
+    case ExecutionMode::NumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL";
+    case ExecutionMode::SchedulerTargetFmaxMhzINTEL: return "SchedulerTargetFmaxMhzINTEL";
+    case ExecutionMode::MaximallyReconvergesKHR: return "MaximallyReconvergesKHR";
+    case ExecutionMode::FPFastMathDefault: return "FPFastMathDefault";
+    case ExecutionMode::StreamingInterfaceINTEL: return "StreamingInterfaceINTEL";
+    case ExecutionMode::RegisterMapInterfaceINTEL: return "RegisterMapInterfaceINTEL";
+    case ExecutionMode::NamedBarrierCountINTEL: return "NamedBarrierCountINTEL";
+    case ExecutionMode::MaximumRegistersINTEL: return "MaximumRegistersINTEL";
+    case ExecutionMode::MaximumRegistersIdINTEL: return "MaximumRegistersIdINTEL";
+    case ExecutionMode::NamedMaximumRegistersINTEL: return "NamedMaximumRegistersINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* StorageClassToString(StorageClass value) {
+    switch (value) {
+    case StorageClass::UniformConstant: return "UniformConstant";
+    case StorageClass::Input: return "Input";
+    case StorageClass::Uniform: return "Uniform";
+    case StorageClass::Output: return "Output";
+    case StorageClass::Workgroup: return "Workgroup";
+    case StorageClass::CrossWorkgroup: return "CrossWorkgroup";
+    case StorageClass::Private: return "Private";
+    case StorageClass::Function: return "Function";
+    case StorageClass::Generic: return "Generic";
+    case StorageClass::PushConstant: return "PushConstant";
+    case StorageClass::AtomicCounter: return "AtomicCounter";
+    case StorageClass::Image: return "Image";
+    case StorageClass::StorageBuffer: return "StorageBuffer";
+    case StorageClass::TileImageEXT: return "TileImageEXT";
+    case StorageClass::TileAttachmentQCOM: return "TileAttachmentQCOM";
+    case StorageClass::NodePayloadAMDX: return "NodePayloadAMDX";
+    case StorageClass::CallableDataKHR: return "CallableDataKHR";
+    case StorageClass::IncomingCallableDataKHR: return "IncomingCallableDataKHR";
+    case StorageClass::RayPayloadKHR: return "RayPayloadKHR";
+    case StorageClass::HitAttributeKHR: return "HitAttributeKHR";
+    case StorageClass::IncomingRayPayloadKHR: return "IncomingRayPayloadKHR";
+    case StorageClass::ShaderRecordBufferKHR: return "ShaderRecordBufferKHR";
+    case StorageClass::PhysicalStorageBuffer: return "PhysicalStorageBuffer";
+    case StorageClass::HitObjectAttributeNV: return "HitObjectAttributeNV";
+    case StorageClass::TaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
+    case StorageClass::CodeSectionINTEL: return "CodeSectionINTEL";
+    case StorageClass::DeviceOnlyINTEL: return "DeviceOnlyINTEL";
+    case StorageClass::HostOnlyINTEL: return "HostOnlyINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* DimToString(Dim value) {
+    switch (value) {
+    case Dim::Dim1D: return "1D";
+    case Dim::Dim2D: return "2D";
+    case Dim::Dim3D: return "3D";
+    case Dim::Cube: return "Cube";
+    case Dim::Rect: return "Rect";
+    case Dim::Buffer: return "Buffer";
+    case Dim::SubpassData: return "SubpassData";
+    case Dim::TileImageDataEXT: return "TileImageDataEXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* SamplerAddressingModeToString(SamplerAddressingMode value) {
+    switch (value) {
+    case SamplerAddressingMode::None: return "None";
+    case SamplerAddressingMode::ClampToEdge: return "ClampToEdge";
+    case SamplerAddressingMode::Clamp: return "Clamp";
+    case SamplerAddressingMode::Repeat: return "Repeat";
+    case SamplerAddressingMode::RepeatMirrored: return "RepeatMirrored";
+    default: return "Unknown";
+    }
+}
+
+inline const char* SamplerFilterModeToString(SamplerFilterMode value) {
+    switch (value) {
+    case SamplerFilterMode::Nearest: return "Nearest";
+    case SamplerFilterMode::Linear: return "Linear";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ImageFormatToString(ImageFormat value) {
+    switch (value) {
+    case ImageFormat::Unknown: return "Unknown";
+    case ImageFormat::Rgba32f: return "Rgba32f";
+    case ImageFormat::Rgba16f: return "Rgba16f";
+    case ImageFormat::R32f: return "R32f";
+    case ImageFormat::Rgba8: return "Rgba8";
+    case ImageFormat::Rgba8Snorm: return "Rgba8Snorm";
+    case ImageFormat::Rg32f: return "Rg32f";
+    case ImageFormat::Rg16f: return "Rg16f";
+    case ImageFormat::R11fG11fB10f: return "R11fG11fB10f";
+    case ImageFormat::R16f: return "R16f";
+    case ImageFormat::Rgba16: return "Rgba16";
+    case ImageFormat::Rgb10A2: return "Rgb10A2";
+    case ImageFormat::Rg16: return "Rg16";
+    case ImageFormat::Rg8: return "Rg8";
+    case ImageFormat::R16: return "R16";
+    case ImageFormat::R8: return "R8";
+    case ImageFormat::Rgba16Snorm: return "Rgba16Snorm";
+    case ImageFormat::Rg16Snorm: return "Rg16Snorm";
+    case ImageFormat::Rg8Snorm: return "Rg8Snorm";
+    case ImageFormat::R16Snorm: return "R16Snorm";
+    case ImageFormat::R8Snorm: return "R8Snorm";
+    case ImageFormat::Rgba32i: return "Rgba32i";
+    case ImageFormat::Rgba16i: return "Rgba16i";
+    case ImageFormat::Rgba8i: return "Rgba8i";
+    case ImageFormat::R32i: return "R32i";
+    case ImageFormat::Rg32i: return "Rg32i";
+    case ImageFormat::Rg16i: return "Rg16i";
+    case ImageFormat::Rg8i: return "Rg8i";
+    case ImageFormat::R16i: return "R16i";
+    case ImageFormat::R8i: return "R8i";
+    case ImageFormat::Rgba32ui: return "Rgba32ui";
+    case ImageFormat::Rgba16ui: return "Rgba16ui";
+    case ImageFormat::Rgba8ui: return "Rgba8ui";
+    case ImageFormat::R32ui: return "R32ui";
+    case ImageFormat::Rgb10a2ui: return "Rgb10a2ui";
+    case ImageFormat::Rg32ui: return "Rg32ui";
+    case ImageFormat::Rg16ui: return "Rg16ui";
+    case ImageFormat::Rg8ui: return "Rg8ui";
+    case ImageFormat::R16ui: return "R16ui";
+    case ImageFormat::R8ui: return "R8ui";
+    case ImageFormat::R64ui: return "R64ui";
+    case ImageFormat::R64i: return "R64i";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ImageChannelOrderToString(ImageChannelOrder value) {
+    switch (value) {
+    case ImageChannelOrder::R: return "R";
+    case ImageChannelOrder::A: return "A";
+    case ImageChannelOrder::RG: return "RG";
+    case ImageChannelOrder::RA: return "RA";
+    case ImageChannelOrder::RGB: return "RGB";
+    case ImageChannelOrder::RGBA: return "RGBA";
+    case ImageChannelOrder::BGRA: return "BGRA";
+    case ImageChannelOrder::ARGB: return "ARGB";
+    case ImageChannelOrder::Intensity: return "Intensity";
+    case ImageChannelOrder::Luminance: return "Luminance";
+    case ImageChannelOrder::Rx: return "Rx";
+    case ImageChannelOrder::RGx: return "RGx";
+    case ImageChannelOrder::RGBx: return "RGBx";
+    case ImageChannelOrder::Depth: return "Depth";
+    case ImageChannelOrder::DepthStencil: return "DepthStencil";
+    case ImageChannelOrder::sRGB: return "sRGB";
+    case ImageChannelOrder::sRGBx: return "sRGBx";
+    case ImageChannelOrder::sRGBA: return "sRGBA";
+    case ImageChannelOrder::sBGRA: return "sBGRA";
+    case ImageChannelOrder::ABGR: return "ABGR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ImageChannelDataTypeToString(ImageChannelDataType value) {
+    switch (value) {
+    case ImageChannelDataType::SnormInt8: return "SnormInt8";
+    case ImageChannelDataType::SnormInt16: return "SnormInt16";
+    case ImageChannelDataType::UnormInt8: return "UnormInt8";
+    case ImageChannelDataType::UnormInt16: return "UnormInt16";
+    case ImageChannelDataType::UnormShort565: return "UnormShort565";
+    case ImageChannelDataType::UnormShort555: return "UnormShort555";
+    case ImageChannelDataType::UnormInt101010: return "UnormInt101010";
+    case ImageChannelDataType::SignedInt8: return "SignedInt8";
+    case ImageChannelDataType::SignedInt16: return "SignedInt16";
+    case ImageChannelDataType::SignedInt32: return "SignedInt32";
+    case ImageChannelDataType::UnsignedInt8: return "UnsignedInt8";
+    case ImageChannelDataType::UnsignedInt16: return "UnsignedInt16";
+    case ImageChannelDataType::UnsignedInt32: return "UnsignedInt32";
+    case ImageChannelDataType::HalfFloat: return "HalfFloat";
+    case ImageChannelDataType::Float: return "Float";
+    case ImageChannelDataType::UnormInt24: return "UnormInt24";
+    case ImageChannelDataType::UnormInt101010_2: return "UnormInt101010_2";
+    case ImageChannelDataType::UnsignedIntRaw10EXT: return "UnsignedIntRaw10EXT";
+    case ImageChannelDataType::UnsignedIntRaw12EXT: return "UnsignedIntRaw12EXT";
+    case ImageChannelDataType::UnormInt2_101010EXT: return "UnormInt2_101010EXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPRoundingModeToString(FPRoundingMode value) {
+    switch (value) {
+    case FPRoundingMode::RTE: return "RTE";
+    case FPRoundingMode::RTZ: return "RTZ";
+    case FPRoundingMode::RTP: return "RTP";
+    case FPRoundingMode::RTN: return "RTN";
+    default: return "Unknown";
+    }
+}
+
+inline const char* LinkageTypeToString(LinkageType value) {
+    switch (value) {
+    case LinkageType::Export: return "Export";
+    case LinkageType::Import: return "Import";
+    case LinkageType::LinkOnceODR: return "LinkOnceODR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* AccessQualifierToString(AccessQualifier value) {
+    switch (value) {
+    case AccessQualifier::ReadOnly: return "ReadOnly";
+    case AccessQualifier::WriteOnly: return "WriteOnly";
+    case AccessQualifier::ReadWrite: return "ReadWrite";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FunctionParameterAttributeToString(FunctionParameterAttribute value) {
+    switch (value) {
+    case FunctionParameterAttribute::Zext: return "Zext";
+    case FunctionParameterAttribute::Sext: return "Sext";
+    case FunctionParameterAttribute::ByVal: return "ByVal";
+    case FunctionParameterAttribute::Sret: return "Sret";
+    case FunctionParameterAttribute::NoAlias: return "NoAlias";
+    case FunctionParameterAttribute::NoCapture: return "NoCapture";
+    case FunctionParameterAttribute::NoWrite: return "NoWrite";
+    case FunctionParameterAttribute::NoReadWrite: return "NoReadWrite";
+    case FunctionParameterAttribute::RuntimeAlignedINTEL: return "RuntimeAlignedINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* DecorationToString(Decoration value) {
+    switch (value) {
+    case Decoration::RelaxedPrecision: return "RelaxedPrecision";
+    case Decoration::SpecId: return "SpecId";
+    case Decoration::Block: return "Block";
+    case Decoration::BufferBlock: return "BufferBlock";
+    case Decoration::RowMajor: return "RowMajor";
+    case Decoration::ColMajor: return "ColMajor";
+    case Decoration::ArrayStride: return "ArrayStride";
+    case Decoration::MatrixStride: return "MatrixStride";
+    case Decoration::GLSLShared: return "GLSLShared";
+    case Decoration::GLSLPacked: return "GLSLPacked";
+    case Decoration::CPacked: return "CPacked";
+    case Decoration::BuiltIn: return "BuiltIn";
+    case Decoration::NoPerspective: return "NoPerspective";
+    case Decoration::Flat: return "Flat";
+    case Decoration::Patch: return "Patch";
+    case Decoration::Centroid: return "Centroid";
+    case Decoration::Sample: return "Sample";
+    case Decoration::Invariant: return "Invariant";
+    case Decoration::Restrict: return "Restrict";
+    case Decoration::Aliased: return "Aliased";
+    case Decoration::Volatile: return "Volatile";
+    case Decoration::Constant: return "Constant";
+    case Decoration::Coherent: return "Coherent";
+    case Decoration::NonWritable: return "NonWritable";
+    case Decoration::NonReadable: return "NonReadable";
+    case Decoration::Uniform: return "Uniform";
+    case Decoration::UniformId: return "UniformId";
+    case Decoration::SaturatedConversion: return "SaturatedConversion";
+    case Decoration::Stream: return "Stream";
+    case Decoration::Location: return "Location";
+    case Decoration::Component: return "Component";
+    case Decoration::Index: return "Index";
+    case Decoration::Binding: return "Binding";
+    case Decoration::DescriptorSet: return "DescriptorSet";
+    case Decoration::Offset: return "Offset";
+    case Decoration::XfbBuffer: return "XfbBuffer";
+    case Decoration::XfbStride: return "XfbStride";
+    case Decoration::FuncParamAttr: return "FuncParamAttr";
+    case Decoration::FPRoundingMode: return "FPRoundingMode";
+    case Decoration::FPFastMathMode: return "FPFastMathMode";
+    case Decoration::LinkageAttributes: return "LinkageAttributes";
+    case Decoration::NoContraction: return "NoContraction";
+    case Decoration::InputAttachmentIndex: return "InputAttachmentIndex";
+    case Decoration::Alignment: return "Alignment";
+    case Decoration::MaxByteOffset: return "MaxByteOffset";
+    case Decoration::AlignmentId: return "AlignmentId";
+    case Decoration::MaxByteOffsetId: return "MaxByteOffsetId";
+    case Decoration::SaturatedToLargestFloat8NormalConversionEXT: return "SaturatedToLargestFloat8NormalConversionEXT";
+    case Decoration::NoSignedWrap: return "NoSignedWrap";
+    case Decoration::NoUnsignedWrap: return "NoUnsignedWrap";
+    case Decoration::WeightTextureQCOM: return "WeightTextureQCOM";
+    case Decoration::BlockMatchTextureQCOM: return "BlockMatchTextureQCOM";
+    case Decoration::BlockMatchSamplerQCOM: return "BlockMatchSamplerQCOM";
+    case Decoration::ExplicitInterpAMD: return "ExplicitInterpAMD";
+    case Decoration::NodeSharesPayloadLimitsWithAMDX: return "NodeSharesPayloadLimitsWithAMDX";
+    case Decoration::NodeMaxPayloadsAMDX: return "NodeMaxPayloadsAMDX";
+    case Decoration::TrackFinishWritingAMDX: return "TrackFinishWritingAMDX";
+    case Decoration::PayloadNodeNameAMDX: return "PayloadNodeNameAMDX";
+    case Decoration::PayloadNodeBaseIndexAMDX: return "PayloadNodeBaseIndexAMDX";
+    case Decoration::PayloadNodeSparseArrayAMDX: return "PayloadNodeSparseArrayAMDX";
+    case Decoration::PayloadNodeArraySizeAMDX: return "PayloadNodeArraySizeAMDX";
+    case Decoration::PayloadDispatchIndirectAMDX: return "PayloadDispatchIndirectAMDX";
+    case Decoration::OverrideCoverageNV: return "OverrideCoverageNV";
+    case Decoration::PassthroughNV: return "PassthroughNV";
+    case Decoration::ViewportRelativeNV: return "ViewportRelativeNV";
+    case Decoration::SecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
+    case Decoration::PerPrimitiveEXT: return "PerPrimitiveEXT";
+    case Decoration::PerViewNV: return "PerViewNV";
+    case Decoration::PerTaskNV: return "PerTaskNV";
+    case Decoration::PerVertexKHR: return "PerVertexKHR";
+    case Decoration::NonUniform: return "NonUniform";
+    case Decoration::RestrictPointer: return "RestrictPointer";
+    case Decoration::AliasedPointer: return "AliasedPointer";
+    case Decoration::HitObjectShaderRecordBufferNV: return "HitObjectShaderRecordBufferNV";
+    case Decoration::BindlessSamplerNV: return "BindlessSamplerNV";
+    case Decoration::BindlessImageNV: return "BindlessImageNV";
+    case Decoration::BoundSamplerNV: return "BoundSamplerNV";
+    case Decoration::BoundImageNV: return "BoundImageNV";
+    case Decoration::SIMTCallINTEL: return "SIMTCallINTEL";
+    case Decoration::ReferencedIndirectlyINTEL: return "ReferencedIndirectlyINTEL";
+    case Decoration::ClobberINTEL: return "ClobberINTEL";
+    case Decoration::SideEffectsINTEL: return "SideEffectsINTEL";
+    case Decoration::VectorComputeVariableINTEL: return "VectorComputeVariableINTEL";
+    case Decoration::FuncParamIOKindINTEL: return "FuncParamIOKindINTEL";
+    case Decoration::VectorComputeFunctionINTEL: return "VectorComputeFunctionINTEL";
+    case Decoration::StackCallINTEL: return "StackCallINTEL";
+    case Decoration::GlobalVariableOffsetINTEL: return "GlobalVariableOffsetINTEL";
+    case Decoration::CounterBuffer: return "CounterBuffer";
+    case Decoration::HlslSemanticGOOGLE: return "HlslSemanticGOOGLE";
+    case Decoration::UserTypeGOOGLE: return "UserTypeGOOGLE";
+    case Decoration::FunctionRoundingModeINTEL: return "FunctionRoundingModeINTEL";
+    case Decoration::FunctionDenormModeINTEL: return "FunctionDenormModeINTEL";
+    case Decoration::RegisterINTEL: return "RegisterINTEL";
+    case Decoration::MemoryINTEL: return "MemoryINTEL";
+    case Decoration::NumbanksINTEL: return "NumbanksINTEL";
+    case Decoration::BankwidthINTEL: return "BankwidthINTEL";
+    case Decoration::MaxPrivateCopiesINTEL: return "MaxPrivateCopiesINTEL";
+    case Decoration::SinglepumpINTEL: return "SinglepumpINTEL";
+    case Decoration::DoublepumpINTEL: return "DoublepumpINTEL";
+    case Decoration::MaxReplicatesINTEL: return "MaxReplicatesINTEL";
+    case Decoration::SimpleDualPortINTEL: return "SimpleDualPortINTEL";
+    case Decoration::MergeINTEL: return "MergeINTEL";
+    case Decoration::BankBitsINTEL: return "BankBitsINTEL";
+    case Decoration::ForcePow2DepthINTEL: return "ForcePow2DepthINTEL";
+    case Decoration::StridesizeINTEL: return "StridesizeINTEL";
+    case Decoration::WordsizeINTEL: return "WordsizeINTEL";
+    case Decoration::TrueDualPortINTEL: return "TrueDualPortINTEL";
+    case Decoration::BurstCoalesceINTEL: return "BurstCoalesceINTEL";
+    case Decoration::CacheSizeINTEL: return "CacheSizeINTEL";
+    case Decoration::DontStaticallyCoalesceINTEL: return "DontStaticallyCoalesceINTEL";
+    case Decoration::PrefetchINTEL: return "PrefetchINTEL";
+    case Decoration::StallEnableINTEL: return "StallEnableINTEL";
+    case Decoration::FuseLoopsInFunctionINTEL: return "FuseLoopsInFunctionINTEL";
+    case Decoration::MathOpDSPModeINTEL: return "MathOpDSPModeINTEL";
+    case Decoration::AliasScopeINTEL: return "AliasScopeINTEL";
+    case Decoration::NoAliasINTEL: return "NoAliasINTEL";
+    case Decoration::InitiationIntervalINTEL: return "InitiationIntervalINTEL";
+    case Decoration::MaxConcurrencyINTEL: return "MaxConcurrencyINTEL";
+    case Decoration::PipelineEnableINTEL: return "PipelineEnableINTEL";
+    case Decoration::BufferLocationINTEL: return "BufferLocationINTEL";
+    case Decoration::IOPipeStorageINTEL: return "IOPipeStorageINTEL";
+    case Decoration::FunctionFloatingPointModeINTEL: return "FunctionFloatingPointModeINTEL";
+    case Decoration::SingleElementVectorINTEL: return "SingleElementVectorINTEL";
+    case Decoration::VectorComputeCallableFunctionINTEL: return "VectorComputeCallableFunctionINTEL";
+    case Decoration::MediaBlockIOINTEL: return "MediaBlockIOINTEL";
+    case Decoration::StallFreeINTEL: return "StallFreeINTEL";
+    case Decoration::FPMaxErrorDecorationINTEL: return "FPMaxErrorDecorationINTEL";
+    case Decoration::LatencyControlLabelINTEL: return "LatencyControlLabelINTEL";
+    case Decoration::LatencyControlConstraintINTEL: return "LatencyControlConstraintINTEL";
+    case Decoration::ConduitKernelArgumentINTEL: return "ConduitKernelArgumentINTEL";
+    case Decoration::RegisterMapKernelArgumentINTEL: return "RegisterMapKernelArgumentINTEL";
+    case Decoration::MMHostInterfaceAddressWidthINTEL: return "MMHostInterfaceAddressWidthINTEL";
+    case Decoration::MMHostInterfaceDataWidthINTEL: return "MMHostInterfaceDataWidthINTEL";
+    case Decoration::MMHostInterfaceLatencyINTEL: return "MMHostInterfaceLatencyINTEL";
+    case Decoration::MMHostInterfaceReadWriteModeINTEL: return "MMHostInterfaceReadWriteModeINTEL";
+    case Decoration::MMHostInterfaceMaxBurstINTEL: return "MMHostInterfaceMaxBurstINTEL";
+    case Decoration::MMHostInterfaceWaitRequestINTEL: return "MMHostInterfaceWaitRequestINTEL";
+    case Decoration::StableKernelArgumentINTEL: return "StableKernelArgumentINTEL";
+    case Decoration::HostAccessINTEL: return "HostAccessINTEL";
+    case Decoration::InitModeINTEL: return "InitModeINTEL";
+    case Decoration::ImplementInRegisterMapINTEL: return "ImplementInRegisterMapINTEL";
+    case Decoration::CacheControlLoadINTEL: return "CacheControlLoadINTEL";
+    case Decoration::CacheControlStoreINTEL: return "CacheControlStoreINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* BuiltInToString(BuiltIn value) {
+    switch (value) {
+    case BuiltIn::Position: return "Position";
+    case BuiltIn::PointSize: return "PointSize";
+    case BuiltIn::ClipDistance: return "ClipDistance";
+    case BuiltIn::CullDistance: return "CullDistance";
+    case BuiltIn::VertexId: return "VertexId";
+    case BuiltIn::InstanceId: return "InstanceId";
+    case BuiltIn::PrimitiveId: return "PrimitiveId";
+    case BuiltIn::InvocationId: return "InvocationId";
+    case BuiltIn::Layer: return "Layer";
+    case BuiltIn::ViewportIndex: return "ViewportIndex";
+    case BuiltIn::TessLevelOuter: return "TessLevelOuter";
+    case BuiltIn::TessLevelInner: return "TessLevelInner";
+    case BuiltIn::TessCoord: return "TessCoord";
+    case BuiltIn::PatchVertices: return "PatchVertices";
+    case BuiltIn::FragCoord: return "FragCoord";
+    case BuiltIn::PointCoord: return "PointCoord";
+    case BuiltIn::FrontFacing: return "FrontFacing";
+    case BuiltIn::SampleId: return "SampleId";
+    case BuiltIn::SamplePosition: return "SamplePosition";
+    case BuiltIn::SampleMask: return "SampleMask";
+    case BuiltIn::FragDepth: return "FragDepth";
+    case BuiltIn::HelperInvocation: return "HelperInvocation";
+    case BuiltIn::NumWorkgroups: return "NumWorkgroups";
+    case BuiltIn::WorkgroupSize: return "WorkgroupSize";
+    case BuiltIn::WorkgroupId: return "WorkgroupId";
+    case BuiltIn::LocalInvocationId: return "LocalInvocationId";
+    case BuiltIn::GlobalInvocationId: return "GlobalInvocationId";
+    case BuiltIn::LocalInvocationIndex: return "LocalInvocationIndex";
+    case BuiltIn::WorkDim: return "WorkDim";
+    case BuiltIn::GlobalSize: return "GlobalSize";
+    case BuiltIn::EnqueuedWorkgroupSize: return "EnqueuedWorkgroupSize";
+    case BuiltIn::GlobalOffset: return "GlobalOffset";
+    case BuiltIn::GlobalLinearId: return "GlobalLinearId";
+    case BuiltIn::SubgroupSize: return "SubgroupSize";
+    case BuiltIn::SubgroupMaxSize: return "SubgroupMaxSize";
+    case BuiltIn::NumSubgroups: return "NumSubgroups";
+    case BuiltIn::NumEnqueuedSubgroups: return "NumEnqueuedSubgroups";
+    case BuiltIn::SubgroupId: return "SubgroupId";
+    case BuiltIn::SubgroupLocalInvocationId: return "SubgroupLocalInvocationId";
+    case BuiltIn::VertexIndex: return "VertexIndex";
+    case BuiltIn::InstanceIndex: return "InstanceIndex";
+    case BuiltIn::CoreIDARM: return "CoreIDARM";
+    case BuiltIn::CoreCountARM: return "CoreCountARM";
+    case BuiltIn::CoreMaxIDARM: return "CoreMaxIDARM";
+    case BuiltIn::WarpIDARM: return "WarpIDARM";
+    case BuiltIn::WarpMaxIDARM: return "WarpMaxIDARM";
+    case BuiltIn::SubgroupEqMask: return "SubgroupEqMask";
+    case BuiltIn::SubgroupGeMask: return "SubgroupGeMask";
+    case BuiltIn::SubgroupGtMask: return "SubgroupGtMask";
+    case BuiltIn::SubgroupLeMask: return "SubgroupLeMask";
+    case BuiltIn::SubgroupLtMask: return "SubgroupLtMask";
+    case BuiltIn::BaseVertex: return "BaseVertex";
+    case BuiltIn::BaseInstance: return "BaseInstance";
+    case BuiltIn::DrawIndex: return "DrawIndex";
+    case BuiltIn::PrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR";
+    case BuiltIn::DeviceIndex: return "DeviceIndex";
+    case BuiltIn::ViewIndex: return "ViewIndex";
+    case BuiltIn::ShadingRateKHR: return "ShadingRateKHR";
+    case BuiltIn::TileOffsetQCOM: return "TileOffsetQCOM";
+    case BuiltIn::TileDimensionQCOM: return "TileDimensionQCOM";
+    case BuiltIn::TileApronSizeQCOM: return "TileApronSizeQCOM";
+    case BuiltIn::BaryCoordNoPerspAMD: return "BaryCoordNoPerspAMD";
+    case BuiltIn::BaryCoordNoPerspCentroidAMD: return "BaryCoordNoPerspCentroidAMD";
+    case BuiltIn::BaryCoordNoPerspSampleAMD: return "BaryCoordNoPerspSampleAMD";
+    case BuiltIn::BaryCoordSmoothAMD: return "BaryCoordSmoothAMD";
+    case BuiltIn::BaryCoordSmoothCentroidAMD: return "BaryCoordSmoothCentroidAMD";
+    case BuiltIn::BaryCoordSmoothSampleAMD: return "BaryCoordSmoothSampleAMD";
+    case BuiltIn::BaryCoordPullModelAMD: return "BaryCoordPullModelAMD";
+    case BuiltIn::FragStencilRefEXT: return "FragStencilRefEXT";
+    case BuiltIn::RemainingRecursionLevelsAMDX: return "RemainingRecursionLevelsAMDX";
+    case BuiltIn::ShaderIndexAMDX: return "ShaderIndexAMDX";
+    case BuiltIn::ViewportMaskNV: return "ViewportMaskNV";
+    case BuiltIn::SecondaryPositionNV: return "SecondaryPositionNV";
+    case BuiltIn::SecondaryViewportMaskNV: return "SecondaryViewportMaskNV";
+    case BuiltIn::PositionPerViewNV: return "PositionPerViewNV";
+    case BuiltIn::ViewportMaskPerViewNV: return "ViewportMaskPerViewNV";
+    case BuiltIn::FullyCoveredEXT: return "FullyCoveredEXT";
+    case BuiltIn::TaskCountNV: return "TaskCountNV";
+    case BuiltIn::PrimitiveCountNV: return "PrimitiveCountNV";
+    case BuiltIn::PrimitiveIndicesNV: return "PrimitiveIndicesNV";
+    case BuiltIn::ClipDistancePerViewNV: return "ClipDistancePerViewNV";
+    case BuiltIn::CullDistancePerViewNV: return "CullDistancePerViewNV";
+    case BuiltIn::LayerPerViewNV: return "LayerPerViewNV";
+    case BuiltIn::MeshViewCountNV: return "MeshViewCountNV";
+    case BuiltIn::MeshViewIndicesNV: return "MeshViewIndicesNV";
+    case BuiltIn::BaryCoordKHR: return "BaryCoordKHR";
+    case BuiltIn::BaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR";
+    case BuiltIn::FragSizeEXT: return "FragSizeEXT";
+    case BuiltIn::FragInvocationCountEXT: return "FragInvocationCountEXT";
+    case BuiltIn::PrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT";
+    case BuiltIn::PrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT";
+    case BuiltIn::PrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT";
+    case BuiltIn::CullPrimitiveEXT: return "CullPrimitiveEXT";
+    case BuiltIn::LaunchIdKHR: return "LaunchIdKHR";
+    case BuiltIn::LaunchSizeKHR: return "LaunchSizeKHR";
+    case BuiltIn::WorldRayOriginKHR: return "WorldRayOriginKHR";
+    case BuiltIn::WorldRayDirectionKHR: return "WorldRayDirectionKHR";
+    case BuiltIn::ObjectRayOriginKHR: return "ObjectRayOriginKHR";
+    case BuiltIn::ObjectRayDirectionKHR: return "ObjectRayDirectionKHR";
+    case BuiltIn::RayTminKHR: return "RayTminKHR";
+    case BuiltIn::RayTmaxKHR: return "RayTmaxKHR";
+    case BuiltIn::InstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
+    case BuiltIn::ObjectToWorldKHR: return "ObjectToWorldKHR";
+    case BuiltIn::WorldToObjectKHR: return "WorldToObjectKHR";
+    case BuiltIn::HitTNV: return "HitTNV";
+    case BuiltIn::HitKindKHR: return "HitKindKHR";
+    case BuiltIn::CurrentRayTimeNV: return "CurrentRayTimeNV";
+    case BuiltIn::HitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
+    case BuiltIn::HitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
+    case BuiltIn::HitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
+    case BuiltIn::IncomingRayFlagsKHR: return "IncomingRayFlagsKHR";
+    case BuiltIn::RayGeometryIndexKHR: return "RayGeometryIndexKHR";
+    case BuiltIn::HitIsSphereNV: return "HitIsSphereNV";
+    case BuiltIn::HitIsLSSNV: return "HitIsLSSNV";
+    case BuiltIn::HitSpherePositionNV: return "HitSpherePositionNV";
+    case BuiltIn::WarpsPerSMNV: return "WarpsPerSMNV";
+    case BuiltIn::SMCountNV: return "SMCountNV";
+    case BuiltIn::WarpIDNV: return "WarpIDNV";
+    case BuiltIn::SMIDNV: return "SMIDNV";
+    case BuiltIn::HitLSSPositionsNV: return "HitLSSPositionsNV";
+    case BuiltIn::HitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
+    case BuiltIn::HitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
+    case BuiltIn::HitSphereRadiusNV: return "HitSphereRadiusNV";
+    case BuiltIn::HitLSSRadiiNV: return "HitLSSRadiiNV";
+    case BuiltIn::ClusterIDNV: return "ClusterIDNV";
+    case BuiltIn::CullMaskKHR: return "CullMaskKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ScopeToString(Scope value) {
+    switch (value) {
+    case Scope::CrossDevice: return "CrossDevice";
+    case Scope::Device: return "Device";
+    case Scope::Workgroup: return "Workgroup";
+    case Scope::Subgroup: return "Subgroup";
+    case Scope::Invocation: return "Invocation";
+    case Scope::QueueFamily: return "QueueFamily";
+    case Scope::ShaderCallKHR: return "ShaderCallKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* GroupOperationToString(GroupOperation value) {
+    switch (value) {
+    case GroupOperation::Reduce: return "Reduce";
+    case GroupOperation::InclusiveScan: return "InclusiveScan";
+    case GroupOperation::ExclusiveScan: return "ExclusiveScan";
+    case GroupOperation::ClusteredReduce: return "ClusteredReduce";
+    case GroupOperation::PartitionedReduceNV: return "PartitionedReduceNV";
+    case GroupOperation::PartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV";
+    case GroupOperation::PartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* KernelEnqueueFlagsToString(KernelEnqueueFlags value) {
+    switch (value) {
+    case KernelEnqueueFlags::NoWait: return "NoWait";
+    case KernelEnqueueFlags::WaitKernel: return "WaitKernel";
+    case KernelEnqueueFlags::WaitWorkGroup: return "WaitWorkGroup";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CapabilityToString(Capability value) {
+    switch (value) {
+    case Capability::Matrix: return "Matrix";
+    case Capability::Shader: return "Shader";
+    case Capability::Geometry: return "Geometry";
+    case Capability::Tessellation: return "Tessellation";
+    case Capability::Addresses: return "Addresses";
+    case Capability::Linkage: return "Linkage";
+    case Capability::Kernel: return "Kernel";
+    case Capability::Vector16: return "Vector16";
+    case Capability::Float16Buffer: return "Float16Buffer";
+    case Capability::Float16: return "Float16";
+    case Capability::Float64: return "Float64";
+    case Capability::Int64: return "Int64";
+    case Capability::Int64Atomics: return "Int64Atomics";
+    case Capability::ImageBasic: return "ImageBasic";
+    case Capability::ImageReadWrite: return "ImageReadWrite";
+    case Capability::ImageMipmap: return "ImageMipmap";
+    case Capability::Pipes: return "Pipes";
+    case Capability::Groups: return "Groups";
+    case Capability::DeviceEnqueue: return "DeviceEnqueue";
+    case Capability::LiteralSampler: return "LiteralSampler";
+    case Capability::AtomicStorage: return "AtomicStorage";
+    case Capability::Int16: return "Int16";
+    case Capability::TessellationPointSize: return "TessellationPointSize";
+    case Capability::GeometryPointSize: return "GeometryPointSize";
+    case Capability::ImageGatherExtended: return "ImageGatherExtended";
+    case Capability::StorageImageMultisample: return "StorageImageMultisample";
+    case Capability::UniformBufferArrayDynamicIndexing: return "UniformBufferArrayDynamicIndexing";
+    case Capability::SampledImageArrayDynamicIndexing: return "SampledImageArrayDynamicIndexing";
+    case Capability::StorageBufferArrayDynamicIndexing: return "StorageBufferArrayDynamicIndexing";
+    case Capability::StorageImageArrayDynamicIndexing: return "StorageImageArrayDynamicIndexing";
+    case Capability::ClipDistance: return "ClipDistance";
+    case Capability::CullDistance: return "CullDistance";
+    case Capability::ImageCubeArray: return "ImageCubeArray";
+    case Capability::SampleRateShading: return "SampleRateShading";
+    case Capability::ImageRect: return "ImageRect";
+    case Capability::SampledRect: return "SampledRect";
+    case Capability::GenericPointer: return "GenericPointer";
+    case Capability::Int8: return "Int8";
+    case Capability::InputAttachment: return "InputAttachment";
+    case Capability::SparseResidency: return "SparseResidency";
+    case Capability::MinLod: return "MinLod";
+    case Capability::Sampled1D: return "Sampled1D";
+    case Capability::Image1D: return "Image1D";
+    case Capability::SampledCubeArray: return "SampledCubeArray";
+    case Capability::SampledBuffer: return "SampledBuffer";
+    case Capability::ImageBuffer: return "ImageBuffer";
+    case Capability::ImageMSArray: return "ImageMSArray";
+    case Capability::StorageImageExtendedFormats: return "StorageImageExtendedFormats";
+    case Capability::ImageQuery: return "ImageQuery";
+    case Capability::DerivativeControl: return "DerivativeControl";
+    case Capability::InterpolationFunction: return "InterpolationFunction";
+    case Capability::TransformFeedback: return "TransformFeedback";
+    case Capability::GeometryStreams: return "GeometryStreams";
+    case Capability::StorageImageReadWithoutFormat: return "StorageImageReadWithoutFormat";
+    case Capability::StorageImageWriteWithoutFormat: return "StorageImageWriteWithoutFormat";
+    case Capability::MultiViewport: return "MultiViewport";
+    case Capability::SubgroupDispatch: return "SubgroupDispatch";
+    case Capability::NamedBarrier: return "NamedBarrier";
+    case Capability::PipeStorage: return "PipeStorage";
+    case Capability::GroupNonUniform: return "GroupNonUniform";
+    case Capability::GroupNonUniformVote: return "GroupNonUniformVote";
+    case Capability::GroupNonUniformArithmetic: return "GroupNonUniformArithmetic";
+    case Capability::GroupNonUniformBallot: return "GroupNonUniformBallot";
+    case Capability::GroupNonUniformShuffle: return "GroupNonUniformShuffle";
+    case Capability::GroupNonUniformShuffleRelative: return "GroupNonUniformShuffleRelative";
+    case Capability::GroupNonUniformClustered: return "GroupNonUniformClustered";
+    case Capability::GroupNonUniformQuad: return "GroupNonUniformQuad";
+    case Capability::ShaderLayer: return "ShaderLayer";
+    case Capability::ShaderViewportIndex: return "ShaderViewportIndex";
+    case Capability::UniformDecoration: return "UniformDecoration";
+    case Capability::CoreBuiltinsARM: return "CoreBuiltinsARM";
+    case Capability::TileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT";
+    case Capability::TileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT";
+    case Capability::TileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT";
+    case Capability::CooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM";
+    case Capability::Float8EXT: return "Float8EXT";
+    case Capability::Float8CooperativeMatrixEXT: return "Float8CooperativeMatrixEXT";
+    case Capability::FragmentShadingRateKHR: return "FragmentShadingRateKHR";
+    case Capability::SubgroupBallotKHR: return "SubgroupBallotKHR";
+    case Capability::DrawParameters: return "DrawParameters";
+    case Capability::WorkgroupMemoryExplicitLayoutKHR: return "WorkgroupMemoryExplicitLayoutKHR";
+    case Capability::WorkgroupMemoryExplicitLayout8BitAccessKHR: return "WorkgroupMemoryExplicitLayout8BitAccessKHR";
+    case Capability::WorkgroupMemoryExplicitLayout16BitAccessKHR: return "WorkgroupMemoryExplicitLayout16BitAccessKHR";
+    case Capability::SubgroupVoteKHR: return "SubgroupVoteKHR";
+    case Capability::StorageBuffer16BitAccess: return "StorageBuffer16BitAccess";
+    case Capability::StorageUniform16: return "StorageUniform16";
+    case Capability::StoragePushConstant16: return "StoragePushConstant16";
+    case Capability::StorageInputOutput16: return "StorageInputOutput16";
+    case Capability::DeviceGroup: return "DeviceGroup";
+    case Capability::MultiView: return "MultiView";
+    case Capability::VariablePointersStorageBuffer: return "VariablePointersStorageBuffer";
+    case Capability::VariablePointers: return "VariablePointers";
+    case Capability::AtomicStorageOps: return "AtomicStorageOps";
+    case Capability::SampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage";
+    case Capability::StorageBuffer8BitAccess: return "StorageBuffer8BitAccess";
+    case Capability::UniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess";
+    case Capability::StoragePushConstant8: return "StoragePushConstant8";
+    case Capability::DenormPreserve: return "DenormPreserve";
+    case Capability::DenormFlushToZero: return "DenormFlushToZero";
+    case Capability::SignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+    case Capability::RoundingModeRTE: return "RoundingModeRTE";
+    case Capability::RoundingModeRTZ: return "RoundingModeRTZ";
+    case Capability::RayQueryProvisionalKHR: return "RayQueryProvisionalKHR";
+    case Capability::RayQueryKHR: return "RayQueryKHR";
+    case Capability::UntypedPointersKHR: return "UntypedPointersKHR";
+    case Capability::RayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
+    case Capability::RayTracingKHR: return "RayTracingKHR";
+    case Capability::TextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM";
+    case Capability::TextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
+    case Capability::TextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
+    case Capability::TileShadingQCOM: return "TileShadingQCOM";
+    case Capability::TextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM";
+    case Capability::Float16ImageAMD: return "Float16ImageAMD";
+    case Capability::ImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
+    case Capability::FragmentMaskAMD: return "FragmentMaskAMD";
+    case Capability::StencilExportEXT: return "StencilExportEXT";
+    case Capability::ImageReadWriteLodAMD: return "ImageReadWriteLodAMD";
+    case Capability::Int64ImageEXT: return "Int64ImageEXT";
+    case Capability::ShaderClockKHR: return "ShaderClockKHR";
+    case Capability::ShaderEnqueueAMDX: return "ShaderEnqueueAMDX";
+    case Capability::QuadControlKHR: return "QuadControlKHR";
+    case Capability::BFloat16TypeKHR: return "BFloat16TypeKHR";
+    case Capability::BFloat16DotProductKHR: return "BFloat16DotProductKHR";
+    case Capability::BFloat16CooperativeMatrixKHR: return "BFloat16CooperativeMatrixKHR";
+    case Capability::SampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV";
+    case Capability::GeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
+    case Capability::ShaderViewportIndexLayerEXT: return "ShaderViewportIndexLayerEXT";
+    case Capability::ShaderViewportMaskNV: return "ShaderViewportMaskNV";
+    case Capability::ShaderStereoViewNV: return "ShaderStereoViewNV";
+    case Capability::PerViewAttributesNV: return "PerViewAttributesNV";
+    case Capability::FragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";
+    case Capability::MeshShadingNV: return "MeshShadingNV";
+    case Capability::ImageFootprintNV: return "ImageFootprintNV";
+    case Capability::MeshShadingEXT: return "MeshShadingEXT";
+    case Capability::FragmentBarycentricKHR: return "FragmentBarycentricKHR";
+    case Capability::ComputeDerivativeGroupQuadsKHR: return "ComputeDerivativeGroupQuadsKHR";
+    case Capability::FragmentDensityEXT: return "FragmentDensityEXT";
+    case Capability::GroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV";
+    case Capability::ShaderNonUniform: return "ShaderNonUniform";
+    case Capability::RuntimeDescriptorArray: return "RuntimeDescriptorArray";
+    case Capability::InputAttachmentArrayDynamicIndexing: return "InputAttachmentArrayDynamicIndexing";
+    case Capability::UniformTexelBufferArrayDynamicIndexing: return "UniformTexelBufferArrayDynamicIndexing";
+    case Capability::StorageTexelBufferArrayDynamicIndexing: return "StorageTexelBufferArrayDynamicIndexing";
+    case Capability::UniformBufferArrayNonUniformIndexing: return "UniformBufferArrayNonUniformIndexing";
+    case Capability::SampledImageArrayNonUniformIndexing: return "SampledImageArrayNonUniformIndexing";
+    case Capability::StorageBufferArrayNonUniformIndexing: return "StorageBufferArrayNonUniformIndexing";
+    case Capability::StorageImageArrayNonUniformIndexing: return "StorageImageArrayNonUniformIndexing";
+    case Capability::InputAttachmentArrayNonUniformIndexing: return "InputAttachmentArrayNonUniformIndexing";
+    case Capability::UniformTexelBufferArrayNonUniformIndexing: return "UniformTexelBufferArrayNonUniformIndexing";
+    case Capability::StorageTexelBufferArrayNonUniformIndexing: return "StorageTexelBufferArrayNonUniformIndexing";
+    case Capability::RayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR";
+    case Capability::RayTracingNV: return "RayTracingNV";
+    case Capability::RayTracingMotionBlurNV: return "RayTracingMotionBlurNV";
+    case Capability::VulkanMemoryModel: return "VulkanMemoryModel";
+    case Capability::VulkanMemoryModelDeviceScope: return "VulkanMemoryModelDeviceScope";
+    case Capability::PhysicalStorageBufferAddresses: return "PhysicalStorageBufferAddresses";
+    case Capability::ComputeDerivativeGroupLinearKHR: return "ComputeDerivativeGroupLinearKHR";
+    case Capability::RayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
+    case Capability::CooperativeMatrixNV: return "CooperativeMatrixNV";
+    case Capability::FragmentShaderSampleInterlockEXT: return "FragmentShaderSampleInterlockEXT";
+    case Capability::FragmentShaderShadingRateInterlockEXT: return "FragmentShaderShadingRateInterlockEXT";
+    case Capability::ShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV";
+    case Capability::FragmentShaderPixelInterlockEXT: return "FragmentShaderPixelInterlockEXT";
+    case Capability::DemoteToHelperInvocation: return "DemoteToHelperInvocation";
+    case Capability::DisplacementMicromapNV: return "DisplacementMicromapNV";
+    case Capability::RayTracingOpacityMicromapEXT: return "RayTracingOpacityMicromapEXT";
+    case Capability::ShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
+    case Capability::BindlessTextureNV: return "BindlessTextureNV";
+    case Capability::RayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
+    case Capability::CooperativeVectorNV: return "CooperativeVectorNV";
+    case Capability::AtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
+    case Capability::RayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
+    case Capability::RawAccessChainsNV: return "RawAccessChainsNV";
+    case Capability::RayTracingSpheresGeometryNV: return "RayTracingSpheresGeometryNV";
+    case Capability::RayTracingLinearSweptSpheresGeometryNV: return "RayTracingLinearSweptSpheresGeometryNV";
+    case Capability::CooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
+    case Capability::CooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
+    case Capability::CooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
+    case Capability::CooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
+    case Capability::CooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
+    case Capability::CooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV";
+    case Capability::RayTracingClusterAccelerationStructureNV: return "RayTracingClusterAccelerationStructureNV";
+    case Capability::TensorAddressingNV: return "TensorAddressingNV";
+    case Capability::SubgroupShuffleINTEL: return "SubgroupShuffleINTEL";
+    case Capability::SubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL";
+    case Capability::SubgroupImageBlockIOINTEL: return "SubgroupImageBlockIOINTEL";
+    case Capability::SubgroupImageMediaBlockIOINTEL: return "SubgroupImageMediaBlockIOINTEL";
+    case Capability::RoundToInfinityINTEL: return "RoundToInfinityINTEL";
+    case Capability::FloatingPointModeINTEL: return "FloatingPointModeINTEL";
+    case Capability::IntegerFunctions2INTEL: return "IntegerFunctions2INTEL";
+    case Capability::FunctionPointersINTEL: return "FunctionPointersINTEL";
+    case Capability::IndirectReferencesINTEL: return "IndirectReferencesINTEL";
+    case Capability::AsmINTEL: return "AsmINTEL";
+    case Capability::AtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT";
+    case Capability::AtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT";
+    case Capability::AtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT";
+    case Capability::VectorComputeINTEL: return "VectorComputeINTEL";
+    case Capability::VectorAnyINTEL: return "VectorAnyINTEL";
+    case Capability::ExpectAssumeKHR: return "ExpectAssumeKHR";
+    case Capability::SubgroupAvcMotionEstimationINTEL: return "SubgroupAvcMotionEstimationINTEL";
+    case Capability::SubgroupAvcMotionEstimationIntraINTEL: return "SubgroupAvcMotionEstimationIntraINTEL";
+    case Capability::SubgroupAvcMotionEstimationChromaINTEL: return "SubgroupAvcMotionEstimationChromaINTEL";
+    case Capability::VariableLengthArrayINTEL: return "VariableLengthArrayINTEL";
+    case Capability::FunctionFloatControlINTEL: return "FunctionFloatControlINTEL";
+    case Capability::FPGAMemoryAttributesINTEL: return "FPGAMemoryAttributesINTEL";
+    case Capability::FPFastMathModeINTEL: return "FPFastMathModeINTEL";
+    case Capability::ArbitraryPrecisionIntegersINTEL: return "ArbitraryPrecisionIntegersINTEL";
+    case Capability::ArbitraryPrecisionFloatingPointINTEL: return "ArbitraryPrecisionFloatingPointINTEL";
+    case Capability::UnstructuredLoopControlsINTEL: return "UnstructuredLoopControlsINTEL";
+    case Capability::FPGALoopControlsINTEL: return "FPGALoopControlsINTEL";
+    case Capability::KernelAttributesINTEL: return "KernelAttributesINTEL";
+    case Capability::FPGAKernelAttributesINTEL: return "FPGAKernelAttributesINTEL";
+    case Capability::FPGAMemoryAccessesINTEL: return "FPGAMemoryAccessesINTEL";
+    case Capability::FPGAClusterAttributesINTEL: return "FPGAClusterAttributesINTEL";
+    case Capability::LoopFuseINTEL: return "LoopFuseINTEL";
+    case Capability::FPGADSPControlINTEL: return "FPGADSPControlINTEL";
+    case Capability::MemoryAccessAliasingINTEL: return "MemoryAccessAliasingINTEL";
+    case Capability::FPGAInvocationPipeliningAttributesINTEL: return "FPGAInvocationPipeliningAttributesINTEL";
+    case Capability::FPGABufferLocationINTEL: return "FPGABufferLocationINTEL";
+    case Capability::ArbitraryPrecisionFixedPointINTEL: return "ArbitraryPrecisionFixedPointINTEL";
+    case Capability::USMStorageClassesINTEL: return "USMStorageClassesINTEL";
+    case Capability::RuntimeAlignedAttributeINTEL: return "RuntimeAlignedAttributeINTEL";
+    case Capability::IOPipesINTEL: return "IOPipesINTEL";
+    case Capability::BlockingPipesINTEL: return "BlockingPipesINTEL";
+    case Capability::FPGARegINTEL: return "FPGARegINTEL";
+    case Capability::DotProductInputAll: return "DotProductInputAll";
+    case Capability::DotProductInput4x8Bit: return "DotProductInput4x8Bit";
+    case Capability::DotProductInput4x8BitPacked: return "DotProductInput4x8BitPacked";
+    case Capability::DotProduct: return "DotProduct";
+    case Capability::RayCullMaskKHR: return "RayCullMaskKHR";
+    case Capability::CooperativeMatrixKHR: return "CooperativeMatrixKHR";
+    case Capability::ReplicatedCompositesEXT: return "ReplicatedCompositesEXT";
+    case Capability::BitInstructions: return "BitInstructions";
+    case Capability::GroupNonUniformRotateKHR: return "GroupNonUniformRotateKHR";
+    case Capability::FloatControls2: return "FloatControls2";
+    case Capability::AtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
+    case Capability::AtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
+    case Capability::LongCompositesINTEL: return "LongCompositesINTEL";
+    case Capability::OptNoneEXT: return "OptNoneEXT";
+    case Capability::AtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
+    case Capability::DebugInfoModuleINTEL: return "DebugInfoModuleINTEL";
+    case Capability::BFloat16ConversionINTEL: return "BFloat16ConversionINTEL";
+    case Capability::SplitBarrierINTEL: return "SplitBarrierINTEL";
+    case Capability::ArithmeticFenceEXT: return "ArithmeticFenceEXT";
+    case Capability::FPGAClusterAttributesV2INTEL: return "FPGAClusterAttributesV2INTEL";
+    case Capability::FPGAKernelAttributesv2INTEL: return "FPGAKernelAttributesv2INTEL";
+    case Capability::FPMaxErrorINTEL: return "FPMaxErrorINTEL";
+    case Capability::FPGALatencyControlINTEL: return "FPGALatencyControlINTEL";
+    case Capability::FPGAArgumentInterfacesINTEL: return "FPGAArgumentInterfacesINTEL";
+    case Capability::GlobalVariableHostAccessINTEL: return "GlobalVariableHostAccessINTEL";
+    case Capability::GlobalVariableFPGADecorationsINTEL: return "GlobalVariableFPGADecorationsINTEL";
+    case Capability::SubgroupBufferPrefetchINTEL: return "SubgroupBufferPrefetchINTEL";
+    case Capability::Subgroup2DBlockIOINTEL: return "Subgroup2DBlockIOINTEL";
+    case Capability::Subgroup2DBlockTransformINTEL: return "Subgroup2DBlockTransformINTEL";
+    case Capability::Subgroup2DBlockTransposeINTEL: return "Subgroup2DBlockTransposeINTEL";
+    case Capability::SubgroupMatrixMultiplyAccumulateINTEL: return "SubgroupMatrixMultiplyAccumulateINTEL";
+    case Capability::GroupUniformArithmeticKHR: return "GroupUniformArithmeticKHR";
+    case Capability::MaskedGatherScatterINTEL: return "MaskedGatherScatterINTEL";
+    case Capability::CacheControlsINTEL: return "CacheControlsINTEL";
+    case Capability::RegisterLimitsINTEL: return "RegisterLimitsINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* RayQueryIntersectionToString(RayQueryIntersection value) {
+    switch (value) {
+    case RayQueryIntersection::RayQueryCandidateIntersectionKHR: return "RayQueryCandidateIntersectionKHR";
+    case RayQueryIntersection::RayQueryCommittedIntersectionKHR: return "RayQueryCommittedIntersectionKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* RayQueryCommittedIntersectionTypeToString(RayQueryCommittedIntersectionType value) {
+    switch (value) {
+    case RayQueryCommittedIntersectionType::RayQueryCommittedIntersectionNoneKHR: return "RayQueryCommittedIntersectionNoneKHR";
+    case RayQueryCommittedIntersectionType::RayQueryCommittedIntersectionTriangleKHR: return "RayQueryCommittedIntersectionTriangleKHR";
+    case RayQueryCommittedIntersectionType::RayQueryCommittedIntersectionGeneratedKHR: return "RayQueryCommittedIntersectionGeneratedKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* RayQueryCandidateIntersectionTypeToString(RayQueryCandidateIntersectionType value) {
+    switch (value) {
+    case RayQueryCandidateIntersectionType::RayQueryCandidateIntersectionTriangleKHR: return "RayQueryCandidateIntersectionTriangleKHR";
+    case RayQueryCandidateIntersectionType::RayQueryCandidateIntersectionAABBKHR: return "RayQueryCandidateIntersectionAABBKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPDenormModeToString(FPDenormMode value) {
+    switch (value) {
+    case FPDenormMode::Preserve: return "Preserve";
+    case FPDenormMode::FlushToZero: return "FlushToZero";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPOperationModeToString(FPOperationMode value) {
+    switch (value) {
+    case FPOperationMode::IEEE: return "IEEE";
+    case FPOperationMode::ALT: return "ALT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* QuantizationModesToString(QuantizationModes value) {
+    switch (value) {
+    case QuantizationModes::TRN: return "TRN";
+    case QuantizationModes::TRN_ZERO: return "TRN_ZERO";
+    case QuantizationModes::RND: return "RND";
+    case QuantizationModes::RND_ZERO: return "RND_ZERO";
+    case QuantizationModes::RND_INF: return "RND_INF";
+    case QuantizationModes::RND_MIN_INF: return "RND_MIN_INF";
+    case QuantizationModes::RND_CONV: return "RND_CONV";
+    case QuantizationModes::RND_CONV_ODD: return "RND_CONV_ODD";
+    default: return "Unknown";
+    }
+}
+
+inline const char* OverflowModesToString(OverflowModes value) {
+    switch (value) {
+    case OverflowModes::WRAP: return "WRAP";
+    case OverflowModes::SAT: return "SAT";
+    case OverflowModes::SAT_ZERO: return "SAT_ZERO";
+    case OverflowModes::SAT_SYM: return "SAT_SYM";
+    default: return "Unknown";
+    }
+}
+
+inline const char* PackedVectorFormatToString(PackedVectorFormat value) {
+    switch (value) {
+    case PackedVectorFormat::PackedVectorFormat4x8Bit: return "PackedVectorFormat4x8Bit";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CooperativeMatrixLayoutToString(CooperativeMatrixLayout value) {
+    switch (value) {
+    case CooperativeMatrixLayout::RowMajorKHR: return "RowMajorKHR";
+    case CooperativeMatrixLayout::ColumnMajorKHR: return "ColumnMajorKHR";
+    case CooperativeMatrixLayout::RowBlockedInterleavedARM: return "RowBlockedInterleavedARM";
+    case CooperativeMatrixLayout::ColumnBlockedInterleavedARM: return "ColumnBlockedInterleavedARM";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CooperativeMatrixUseToString(CooperativeMatrixUse value) {
+    switch (value) {
+    case CooperativeMatrixUse::MatrixAKHR: return "MatrixAKHR";
+    case CooperativeMatrixUse::MatrixBKHR: return "MatrixBKHR";
+    case CooperativeMatrixUse::MatrixAccumulatorKHR: return "MatrixAccumulatorKHR";
+    default: return "Unknown";
+    }
+}
+
+inline const char* TensorClampModeToString(TensorClampMode value) {
+    switch (value) {
+    case TensorClampMode::Undefined: return "Undefined";
+    case TensorClampMode::Constant: return "Constant";
+    case TensorClampMode::ClampToEdge: return "ClampToEdge";
+    case TensorClampMode::Repeat: return "Repeat";
+    case TensorClampMode::RepeatMirrored: return "RepeatMirrored";
+    default: return "Unknown";
+    }
+}
+
+inline const char* InitializationModeQualifierToString(InitializationModeQualifier value) {
+    switch (value) {
+    case InitializationModeQualifier::InitOnDeviceReprogramINTEL: return "InitOnDeviceReprogramINTEL";
+    case InitializationModeQualifier::InitOnDeviceResetINTEL: return "InitOnDeviceResetINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* HostAccessQualifierToString(HostAccessQualifier value) {
+    switch (value) {
+    case HostAccessQualifier::NoneINTEL: return "NoneINTEL";
+    case HostAccessQualifier::ReadINTEL: return "ReadINTEL";
+    case HostAccessQualifier::WriteINTEL: return "WriteINTEL";
+    case HostAccessQualifier::ReadWriteINTEL: return "ReadWriteINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* LoadCacheControlToString(LoadCacheControl value) {
+    switch (value) {
+    case LoadCacheControl::UncachedINTEL: return "UncachedINTEL";
+    case LoadCacheControl::CachedINTEL: return "CachedINTEL";
+    case LoadCacheControl::StreamingINTEL: return "StreamingINTEL";
+    case LoadCacheControl::InvalidateAfterReadINTEL: return "InvalidateAfterReadINTEL";
+    case LoadCacheControl::ConstCachedINTEL: return "ConstCachedINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* StoreCacheControlToString(StoreCacheControl value) {
+    switch (value) {
+    case StoreCacheControl::UncachedINTEL: return "UncachedINTEL";
+    case StoreCacheControl::WriteThroughINTEL: return "WriteThroughINTEL";
+    case StoreCacheControl::WriteBackINTEL: return "WriteBackINTEL";
+    case StoreCacheControl::StreamingINTEL: return "StreamingINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* NamedMaximumNumberOfRegistersToString(NamedMaximumNumberOfRegisters value) {
+    switch (value) {
+    case NamedMaximumNumberOfRegisters::AutoINTEL: return "AutoINTEL";
+    default: return "Unknown";
+    }
+}
+
+inline const char* FPEncodingToString(FPEncoding value) {
+    switch (value) {
+    case FPEncoding::BFloat16KHR: return "BFloat16KHR";
+    case FPEncoding::Float8E4M3EXT: return "Float8E4M3EXT";
+    case FPEncoding::Float8E5M2EXT: return "Float8E5M2EXT";
+    default: return "Unknown";
+    }
+}
+
+inline const char* CooperativeVectorMatrixLayoutToString(CooperativeVectorMatrixLayout value) {
+    switch (value) {
+    case CooperativeVectorMatrixLayout::RowMajorNV: return "RowMajorNV";
+    case CooperativeVectorMatrixLayout::ColumnMajorNV: return "ColumnMajorNV";
+    case CooperativeVectorMatrixLayout::InferencingOptimalNV: return "InferencingOptimalNV";
+    case CooperativeVectorMatrixLayout::TrainingOptimalNV: return "TrainingOptimalNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ComponentTypeToString(ComponentType value) {
+    switch (value) {
+    case ComponentType::Float16NV: return "Float16NV";
+    case ComponentType::Float32NV: return "Float32NV";
+    case ComponentType::Float64NV: return "Float64NV";
+    case ComponentType::SignedInt8NV: return "SignedInt8NV";
+    case ComponentType::SignedInt16NV: return "SignedInt16NV";
+    case ComponentType::SignedInt32NV: return "SignedInt32NV";
+    case ComponentType::SignedInt64NV: return "SignedInt64NV";
+    case ComponentType::UnsignedInt8NV: return "UnsignedInt8NV";
+    case ComponentType::UnsignedInt16NV: return "UnsignedInt16NV";
+    case ComponentType::UnsignedInt32NV: return "UnsignedInt32NV";
+    case ComponentType::UnsignedInt64NV: return "UnsignedInt64NV";
+    case ComponentType::SignedInt8PackedNV: return "SignedInt8PackedNV";
+    case ComponentType::UnsignedInt8PackedNV: return "UnsignedInt8PackedNV";
+    case ComponentType::FloatE4M3NV: return "FloatE4M3NV";
+    case ComponentType::FloatE5M2NV: return "FloatE5M2NV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* OpToString(Op value) {
+    switch (value) {
+    case Op::OpNop: return "OpNop";
+    case Op::OpUndef: return "OpUndef";
+    case Op::OpSourceContinued: return "OpSourceContinued";
+    case Op::OpSource: return "OpSource";
+    case Op::OpSourceExtension: return "OpSourceExtension";
+    case Op::OpName: return "OpName";
+    case Op::OpMemberName: return "OpMemberName";
+    case Op::OpString: return "OpString";
+    case Op::OpLine: return "OpLine";
+    case Op::OpExtension: return "OpExtension";
+    case Op::OpExtInstImport: return "OpExtInstImport";
+    case Op::OpExtInst: return "OpExtInst";
+    case Op::OpMemoryModel: return "OpMemoryModel";
+    case Op::OpEntryPoint: return "OpEntryPoint";
+    case Op::OpExecutionMode: return "OpExecutionMode";
+    case Op::OpCapability: return "OpCapability";
+    case Op::OpTypeVoid: return "OpTypeVoid";
+    case Op::OpTypeBool: return "OpTypeBool";
+    case Op::OpTypeInt: return "OpTypeInt";
+    case Op::OpTypeFloat: return "OpTypeFloat";
+    case Op::OpTypeVector: return "OpTypeVector";
+    case Op::OpTypeMatrix: return "OpTypeMatrix";
+    case Op::OpTypeImage: return "OpTypeImage";
+    case Op::OpTypeSampler: return "OpTypeSampler";
+    case Op::OpTypeSampledImage: return "OpTypeSampledImage";
+    case Op::OpTypeArray: return "OpTypeArray";
+    case Op::OpTypeRuntimeArray: return "OpTypeRuntimeArray";
+    case Op::OpTypeStruct: return "OpTypeStruct";
+    case Op::OpTypeOpaque: return "OpTypeOpaque";
+    case Op::OpTypePointer: return "OpTypePointer";
+    case Op::OpTypeFunction: return "OpTypeFunction";
+    case Op::OpTypeEvent: return "OpTypeEvent";
+    case Op::OpTypeDeviceEvent: return "OpTypeDeviceEvent";
+    case Op::OpTypeReserveId: return "OpTypeReserveId";
+    case Op::OpTypeQueue: return "OpTypeQueue";
+    case Op::OpTypePipe: return "OpTypePipe";
+    case Op::OpTypeForwardPointer: return "OpTypeForwardPointer";
+    case Op::OpConstantTrue: return "OpConstantTrue";
+    case Op::OpConstantFalse: return "OpConstantFalse";
+    case Op::OpConstant: return "OpConstant";
+    case Op::OpConstantComposite: return "OpConstantComposite";
+    case Op::OpConstantSampler: return "OpConstantSampler";
+    case Op::OpConstantNull: return "OpConstantNull";
+    case Op::OpSpecConstantTrue: return "OpSpecConstantTrue";
+    case Op::OpSpecConstantFalse: return "OpSpecConstantFalse";
+    case Op::OpSpecConstant: return "OpSpecConstant";
+    case Op::OpSpecConstantComposite: return "OpSpecConstantComposite";
+    case Op::OpSpecConstantOp: return "OpSpecConstantOp";
+    case Op::OpFunction: return "OpFunction";
+    case Op::OpFunctionParameter: return "OpFunctionParameter";
+    case Op::OpFunctionEnd: return "OpFunctionEnd";
+    case Op::OpFunctionCall: return "OpFunctionCall";
+    case Op::OpVariable: return "OpVariable";
+    case Op::OpImageTexelPointer: return "OpImageTexelPointer";
+    case Op::OpLoad: return "OpLoad";
+    case Op::OpStore: return "OpStore";
+    case Op::OpCopyMemory: return "OpCopyMemory";
+    case Op::OpCopyMemorySized: return "OpCopyMemorySized";
+    case Op::OpAccessChain: return "OpAccessChain";
+    case Op::OpInBoundsAccessChain: return "OpInBoundsAccessChain";
+    case Op::OpPtrAccessChain: return "OpPtrAccessChain";
+    case Op::OpArrayLength: return "OpArrayLength";
+    case Op::OpGenericPtrMemSemantics: return "OpGenericPtrMemSemantics";
+    case Op::OpInBoundsPtrAccessChain: return "OpInBoundsPtrAccessChain";
+    case Op::OpDecorate: return "OpDecorate";
+    case Op::OpMemberDecorate: return "OpMemberDecorate";
+    case Op::OpDecorationGroup: return "OpDecorationGroup";
+    case Op::OpGroupDecorate: return "OpGroupDecorate";
+    case Op::OpGroupMemberDecorate: return "OpGroupMemberDecorate";
+    case Op::OpVectorExtractDynamic: return "OpVectorExtractDynamic";
+    case Op::OpVectorInsertDynamic: return "OpVectorInsertDynamic";
+    case Op::OpVectorShuffle: return "OpVectorShuffle";
+    case Op::OpCompositeConstruct: return "OpCompositeConstruct";
+    case Op::OpCompositeExtract: return "OpCompositeExtract";
+    case Op::OpCompositeInsert: return "OpCompositeInsert";
+    case Op::OpCopyObject: return "OpCopyObject";
+    case Op::OpTranspose: return "OpTranspose";
+    case Op::OpSampledImage: return "OpSampledImage";
+    case Op::OpImageSampleImplicitLod: return "OpImageSampleImplicitLod";
+    case Op::OpImageSampleExplicitLod: return "OpImageSampleExplicitLod";
+    case Op::OpImageSampleDrefImplicitLod: return "OpImageSampleDrefImplicitLod";
+    case Op::OpImageSampleDrefExplicitLod: return "OpImageSampleDrefExplicitLod";
+    case Op::OpImageSampleProjImplicitLod: return "OpImageSampleProjImplicitLod";
+    case Op::OpImageSampleProjExplicitLod: return "OpImageSampleProjExplicitLod";
+    case Op::OpImageSampleProjDrefImplicitLod: return "OpImageSampleProjDrefImplicitLod";
+    case Op::OpImageSampleProjDrefExplicitLod: return "OpImageSampleProjDrefExplicitLod";
+    case Op::OpImageFetch: return "OpImageFetch";
+    case Op::OpImageGather: return "OpImageGather";
+    case Op::OpImageDrefGather: return "OpImageDrefGather";
+    case Op::OpImageRead: return "OpImageRead";
+    case Op::OpImageWrite: return "OpImageWrite";
+    case Op::OpImage: return "OpImage";
+    case Op::OpImageQueryFormat: return "OpImageQueryFormat";
+    case Op::OpImageQueryOrder: return "OpImageQueryOrder";
+    case Op::OpImageQuerySizeLod: return "OpImageQuerySizeLod";
+    case Op::OpImageQuerySize: return "OpImageQuerySize";
+    case Op::OpImageQueryLod: return "OpImageQueryLod";
+    case Op::OpImageQueryLevels: return "OpImageQueryLevels";
+    case Op::OpImageQuerySamples: return "OpImageQuerySamples";
+    case Op::OpConvertFToU: return "OpConvertFToU";
+    case Op::OpConvertFToS: return "OpConvertFToS";
+    case Op::OpConvertSToF: return "OpConvertSToF";
+    case Op::OpConvertUToF: return "OpConvertUToF";
+    case Op::OpUConvert: return "OpUConvert";
+    case Op::OpSConvert: return "OpSConvert";
+    case Op::OpFConvert: return "OpFConvert";
+    case Op::OpQuantizeToF16: return "OpQuantizeToF16";
+    case Op::OpConvertPtrToU: return "OpConvertPtrToU";
+    case Op::OpSatConvertSToU: return "OpSatConvertSToU";
+    case Op::OpSatConvertUToS: return "OpSatConvertUToS";
+    case Op::OpConvertUToPtr: return "OpConvertUToPtr";
+    case Op::OpPtrCastToGeneric: return "OpPtrCastToGeneric";
+    case Op::OpGenericCastToPtr: return "OpGenericCastToPtr";
+    case Op::OpGenericCastToPtrExplicit: return "OpGenericCastToPtrExplicit";
+    case Op::OpBitcast: return "OpBitcast";
+    case Op::OpSNegate: return "OpSNegate";
+    case Op::OpFNegate: return "OpFNegate";
+    case Op::OpIAdd: return "OpIAdd";
+    case Op::OpFAdd: return "OpFAdd";
+    case Op::OpISub: return "OpISub";
+    case Op::OpFSub: return "OpFSub";
+    case Op::OpIMul: return "OpIMul";
+    case Op::OpFMul: return "OpFMul";
+    case Op::OpUDiv: return "OpUDiv";
+    case Op::OpSDiv: return "OpSDiv";
+    case Op::OpFDiv: return "OpFDiv";
+    case Op::OpUMod: return "OpUMod";
+    case Op::OpSRem: return "OpSRem";
+    case Op::OpSMod: return "OpSMod";
+    case Op::OpFRem: return "OpFRem";
+    case Op::OpFMod: return "OpFMod";
+    case Op::OpVectorTimesScalar: return "OpVectorTimesScalar";
+    case Op::OpMatrixTimesScalar: return "OpMatrixTimesScalar";
+    case Op::OpVectorTimesMatrix: return "OpVectorTimesMatrix";
+    case Op::OpMatrixTimesVector: return "OpMatrixTimesVector";
+    case Op::OpMatrixTimesMatrix: return "OpMatrixTimesMatrix";
+    case Op::OpOuterProduct: return "OpOuterProduct";
+    case Op::OpDot: return "OpDot";
+    case Op::OpIAddCarry: return "OpIAddCarry";
+    case Op::OpISubBorrow: return "OpISubBorrow";
+    case Op::OpUMulExtended: return "OpUMulExtended";
+    case Op::OpSMulExtended: return "OpSMulExtended";
+    case Op::OpAny: return "OpAny";
+    case Op::OpAll: return "OpAll";
+    case Op::OpIsNan: return "OpIsNan";
+    case Op::OpIsInf: return "OpIsInf";
+    case Op::OpIsFinite: return "OpIsFinite";
+    case Op::OpIsNormal: return "OpIsNormal";
+    case Op::OpSignBitSet: return "OpSignBitSet";
+    case Op::OpLessOrGreater: return "OpLessOrGreater";
+    case Op::OpOrdered: return "OpOrdered";
+    case Op::OpUnordered: return "OpUnordered";
+    case Op::OpLogicalEqual: return "OpLogicalEqual";
+    case Op::OpLogicalNotEqual: return "OpLogicalNotEqual";
+    case Op::OpLogicalOr: return "OpLogicalOr";
+    case Op::OpLogicalAnd: return "OpLogicalAnd";
+    case Op::OpLogicalNot: return "OpLogicalNot";
+    case Op::OpSelect: return "OpSelect";
+    case Op::OpIEqual: return "OpIEqual";
+    case Op::OpINotEqual: return "OpINotEqual";
+    case Op::OpUGreaterThan: return "OpUGreaterThan";
+    case Op::OpSGreaterThan: return "OpSGreaterThan";
+    case Op::OpUGreaterThanEqual: return "OpUGreaterThanEqual";
+    case Op::OpSGreaterThanEqual: return "OpSGreaterThanEqual";
+    case Op::OpULessThan: return "OpULessThan";
+    case Op::OpSLessThan: return "OpSLessThan";
+    case Op::OpULessThanEqual: return "OpULessThanEqual";
+    case Op::OpSLessThanEqual: return "OpSLessThanEqual";
+    case Op::OpFOrdEqual: return "OpFOrdEqual";
+    case Op::OpFUnordEqual: return "OpFUnordEqual";
+    case Op::OpFOrdNotEqual: return "OpFOrdNotEqual";
+    case Op::OpFUnordNotEqual: return "OpFUnordNotEqual";
+    case Op::OpFOrdLessThan: return "OpFOrdLessThan";
+    case Op::OpFUnordLessThan: return "OpFUnordLessThan";
+    case Op::OpFOrdGreaterThan: return "OpFOrdGreaterThan";
+    case Op::OpFUnordGreaterThan: return "OpFUnordGreaterThan";
+    case Op::OpFOrdLessThanEqual: return "OpFOrdLessThanEqual";
+    case Op::OpFUnordLessThanEqual: return "OpFUnordLessThanEqual";
+    case Op::OpFOrdGreaterThanEqual: return "OpFOrdGreaterThanEqual";
+    case Op::OpFUnordGreaterThanEqual: return "OpFUnordGreaterThanEqual";
+    case Op::OpShiftRightLogical: return "OpShiftRightLogical";
+    case Op::OpShiftRightArithmetic: return "OpShiftRightArithmetic";
+    case Op::OpShiftLeftLogical: return "OpShiftLeftLogical";
+    case Op::OpBitwiseOr: return "OpBitwiseOr";
+    case Op::OpBitwiseXor: return "OpBitwiseXor";
+    case Op::OpBitwiseAnd: return "OpBitwiseAnd";
+    case Op::OpNot: return "OpNot";
+    case Op::OpBitFieldInsert: return "OpBitFieldInsert";
+    case Op::OpBitFieldSExtract: return "OpBitFieldSExtract";
+    case Op::OpBitFieldUExtract: return "OpBitFieldUExtract";
+    case Op::OpBitReverse: return "OpBitReverse";
+    case Op::OpBitCount: return "OpBitCount";
+    case Op::OpDPdx: return "OpDPdx";
+    case Op::OpDPdy: return "OpDPdy";
+    case Op::OpFwidth: return "OpFwidth";
+    case Op::OpDPdxFine: return "OpDPdxFine";
+    case Op::OpDPdyFine: return "OpDPdyFine";
+    case Op::OpFwidthFine: return "OpFwidthFine";
+    case Op::OpDPdxCoarse: return "OpDPdxCoarse";
+    case Op::OpDPdyCoarse: return "OpDPdyCoarse";
+    case Op::OpFwidthCoarse: return "OpFwidthCoarse";
+    case Op::OpEmitVertex: return "OpEmitVertex";
+    case Op::OpEndPrimitive: return "OpEndPrimitive";
+    case Op::OpEmitStreamVertex: return "OpEmitStreamVertex";
+    case Op::OpEndStreamPrimitive: return "OpEndStreamPrimitive";
+    case Op::OpControlBarrier: return "OpControlBarrier";
+    case Op::OpMemoryBarrier: return "OpMemoryBarrier";
+    case Op::OpAtomicLoad: return "OpAtomicLoad";
+    case Op::OpAtomicStore: return "OpAtomicStore";
+    case Op::OpAtomicExchange: return "OpAtomicExchange";
+    case Op::OpAtomicCompareExchange: return "OpAtomicCompareExchange";
+    case Op::OpAtomicCompareExchangeWeak: return "OpAtomicCompareExchangeWeak";
+    case Op::OpAtomicIIncrement: return "OpAtomicIIncrement";
+    case Op::OpAtomicIDecrement: return "OpAtomicIDecrement";
+    case Op::OpAtomicIAdd: return "OpAtomicIAdd";
+    case Op::OpAtomicISub: return "OpAtomicISub";
+    case Op::OpAtomicSMin: return "OpAtomicSMin";
+    case Op::OpAtomicUMin: return "OpAtomicUMin";
+    case Op::OpAtomicSMax: return "OpAtomicSMax";
+    case Op::OpAtomicUMax: return "OpAtomicUMax";
+    case Op::OpAtomicAnd: return "OpAtomicAnd";
+    case Op::OpAtomicOr: return "OpAtomicOr";
+    case Op::OpAtomicXor: return "OpAtomicXor";
+    case Op::OpPhi: return "OpPhi";
+    case Op::OpLoopMerge: return "OpLoopMerge";
+    case Op::OpSelectionMerge: return "OpSelectionMerge";
+    case Op::OpLabel: return "OpLabel";
+    case Op::OpBranch: return "OpBranch";
+    case Op::OpBranchConditional: return "OpBranchConditional";
+    case Op::OpSwitch: return "OpSwitch";
+    case Op::OpKill: return "OpKill";
+    case Op::OpReturn: return "OpReturn";
+    case Op::OpReturnValue: return "OpReturnValue";
+    case Op::OpUnreachable: return "OpUnreachable";
+    case Op::OpLifetimeStart: return "OpLifetimeStart";
+    case Op::OpLifetimeStop: return "OpLifetimeStop";
+    case Op::OpGroupAsyncCopy: return "OpGroupAsyncCopy";
+    case Op::OpGroupWaitEvents: return "OpGroupWaitEvents";
+    case Op::OpGroupAll: return "OpGroupAll";
+    case Op::OpGroupAny: return "OpGroupAny";
+    case Op::OpGroupBroadcast: return "OpGroupBroadcast";
+    case Op::OpGroupIAdd: return "OpGroupIAdd";
+    case Op::OpGroupFAdd: return "OpGroupFAdd";
+    case Op::OpGroupFMin: return "OpGroupFMin";
+    case Op::OpGroupUMin: return "OpGroupUMin";
+    case Op::OpGroupSMin: return "OpGroupSMin";
+    case Op::OpGroupFMax: return "OpGroupFMax";
+    case Op::OpGroupUMax: return "OpGroupUMax";
+    case Op::OpGroupSMax: return "OpGroupSMax";
+    case Op::OpReadPipe: return "OpReadPipe";
+    case Op::OpWritePipe: return "OpWritePipe";
+    case Op::OpReservedReadPipe: return "OpReservedReadPipe";
+    case Op::OpReservedWritePipe: return "OpReservedWritePipe";
+    case Op::OpReserveReadPipePackets: return "OpReserveReadPipePackets";
+    case Op::OpReserveWritePipePackets: return "OpReserveWritePipePackets";
+    case Op::OpCommitReadPipe: return "OpCommitReadPipe";
+    case Op::OpCommitWritePipe: return "OpCommitWritePipe";
+    case Op::OpIsValidReserveId: return "OpIsValidReserveId";
+    case Op::OpGetNumPipePackets: return "OpGetNumPipePackets";
+    case Op::OpGetMaxPipePackets: return "OpGetMaxPipePackets";
+    case Op::OpGroupReserveReadPipePackets: return "OpGroupReserveReadPipePackets";
+    case Op::OpGroupReserveWritePipePackets: return "OpGroupReserveWritePipePackets";
+    case Op::OpGroupCommitReadPipe: return "OpGroupCommitReadPipe";
+    case Op::OpGroupCommitWritePipe: return "OpGroupCommitWritePipe";
+    case Op::OpEnqueueMarker: return "OpEnqueueMarker";
+    case Op::OpEnqueueKernel: return "OpEnqueueKernel";
+    case Op::OpGetKernelNDrangeSubGroupCount: return "OpGetKernelNDrangeSubGroupCount";
+    case Op::OpGetKernelNDrangeMaxSubGroupSize: return "OpGetKernelNDrangeMaxSubGroupSize";
+    case Op::OpGetKernelWorkGroupSize: return "OpGetKernelWorkGroupSize";
+    case Op::OpGetKernelPreferredWorkGroupSizeMultiple: return "OpGetKernelPreferredWorkGroupSizeMultiple";
+    case Op::OpRetainEvent: return "OpRetainEvent";
+    case Op::OpReleaseEvent: return "OpReleaseEvent";
+    case Op::OpCreateUserEvent: return "OpCreateUserEvent";
+    case Op::OpIsValidEvent: return "OpIsValidEvent";
+    case Op::OpSetUserEventStatus: return "OpSetUserEventStatus";
+    case Op::OpCaptureEventProfilingInfo: return "OpCaptureEventProfilingInfo";
+    case Op::OpGetDefaultQueue: return "OpGetDefaultQueue";
+    case Op::OpBuildNDRange: return "OpBuildNDRange";
+    case Op::OpImageSparseSampleImplicitLod: return "OpImageSparseSampleImplicitLod";
+    case Op::OpImageSparseSampleExplicitLod: return "OpImageSparseSampleExplicitLod";
+    case Op::OpImageSparseSampleDrefImplicitLod: return "OpImageSparseSampleDrefImplicitLod";
+    case Op::OpImageSparseSampleDrefExplicitLod: return "OpImageSparseSampleDrefExplicitLod";
+    case Op::OpImageSparseSampleProjImplicitLod: return "OpImageSparseSampleProjImplicitLod";
+    case Op::OpImageSparseSampleProjExplicitLod: return "OpImageSparseSampleProjExplicitLod";
+    case Op::OpImageSparseSampleProjDrefImplicitLod: return "OpImageSparseSampleProjDrefImplicitLod";
+    case Op::OpImageSparseSampleProjDrefExplicitLod: return "OpImageSparseSampleProjDrefExplicitLod";
+    case Op::OpImageSparseFetch: return "OpImageSparseFetch";
+    case Op::OpImageSparseGather: return "OpImageSparseGather";
+    case Op::OpImageSparseDrefGather: return "OpImageSparseDrefGather";
+    case Op::OpImageSparseTexelsResident: return "OpImageSparseTexelsResident";
+    case Op::OpNoLine: return "OpNoLine";
+    case Op::OpAtomicFlagTestAndSet: return "OpAtomicFlagTestAndSet";
+    case Op::OpAtomicFlagClear: return "OpAtomicFlagClear";
+    case Op::OpImageSparseRead: return "OpImageSparseRead";
+    case Op::OpSizeOf: return "OpSizeOf";
+    case Op::OpTypePipeStorage: return "OpTypePipeStorage";
+    case Op::OpConstantPipeStorage: return "OpConstantPipeStorage";
+    case Op::OpCreatePipeFromPipeStorage: return "OpCreatePipeFromPipeStorage";
+    case Op::OpGetKernelLocalSizeForSubgroupCount: return "OpGetKernelLocalSizeForSubgroupCount";
+    case Op::OpGetKernelMaxNumSubgroups: return "OpGetKernelMaxNumSubgroups";
+    case Op::OpTypeNamedBarrier: return "OpTypeNamedBarrier";
+    case Op::OpNamedBarrierInitialize: return "OpNamedBarrierInitialize";
+    case Op::OpMemoryNamedBarrier: return "OpMemoryNamedBarrier";
+    case Op::OpModuleProcessed: return "OpModuleProcessed";
+    case Op::OpExecutionModeId: return "OpExecutionModeId";
+    case Op::OpDecorateId: return "OpDecorateId";
+    case Op::OpGroupNonUniformElect: return "OpGroupNonUniformElect";
+    case Op::OpGroupNonUniformAll: return "OpGroupNonUniformAll";
+    case Op::OpGroupNonUniformAny: return "OpGroupNonUniformAny";
+    case Op::OpGroupNonUniformAllEqual: return "OpGroupNonUniformAllEqual";
+    case Op::OpGroupNonUniformBroadcast: return "OpGroupNonUniformBroadcast";
+    case Op::OpGroupNonUniformBroadcastFirst: return "OpGroupNonUniformBroadcastFirst";
+    case Op::OpGroupNonUniformBallot: return "OpGroupNonUniformBallot";
+    case Op::OpGroupNonUniformInverseBallot: return "OpGroupNonUniformInverseBallot";
+    case Op::OpGroupNonUniformBallotBitExtract: return "OpGroupNonUniformBallotBitExtract";
+    case Op::OpGroupNonUniformBallotBitCount: return "OpGroupNonUniformBallotBitCount";
+    case Op::OpGroupNonUniformBallotFindLSB: return "OpGroupNonUniformBallotFindLSB";
+    case Op::OpGroupNonUniformBallotFindMSB: return "OpGroupNonUniformBallotFindMSB";
+    case Op::OpGroupNonUniformShuffle: return "OpGroupNonUniformShuffle";
+    case Op::OpGroupNonUniformShuffleXor: return "OpGroupNonUniformShuffleXor";
+    case Op::OpGroupNonUniformShuffleUp: return "OpGroupNonUniformShuffleUp";
+    case Op::OpGroupNonUniformShuffleDown: return "OpGroupNonUniformShuffleDown";
+    case Op::OpGroupNonUniformIAdd: return "OpGroupNonUniformIAdd";
+    case Op::OpGroupNonUniformFAdd: return "OpGroupNonUniformFAdd";
+    case Op::OpGroupNonUniformIMul: return "OpGroupNonUniformIMul";
+    case Op::OpGroupNonUniformFMul: return "OpGroupNonUniformFMul";
+    case Op::OpGroupNonUniformSMin: return "OpGroupNonUniformSMin";
+    case Op::OpGroupNonUniformUMin: return "OpGroupNonUniformUMin";
+    case Op::OpGroupNonUniformFMin: return "OpGroupNonUniformFMin";
+    case Op::OpGroupNonUniformSMax: return "OpGroupNonUniformSMax";
+    case Op::OpGroupNonUniformUMax: return "OpGroupNonUniformUMax";
+    case Op::OpGroupNonUniformFMax: return "OpGroupNonUniformFMax";
+    case Op::OpGroupNonUniformBitwiseAnd: return "OpGroupNonUniformBitwiseAnd";
+    case Op::OpGroupNonUniformBitwiseOr: return "OpGroupNonUniformBitwiseOr";
+    case Op::OpGroupNonUniformBitwiseXor: return "OpGroupNonUniformBitwiseXor";
+    case Op::OpGroupNonUniformLogicalAnd: return "OpGroupNonUniformLogicalAnd";
+    case Op::OpGroupNonUniformLogicalOr: return "OpGroupNonUniformLogicalOr";
+    case Op::OpGroupNonUniformLogicalXor: return "OpGroupNonUniformLogicalXor";
+    case Op::OpGroupNonUniformQuadBroadcast: return "OpGroupNonUniformQuadBroadcast";
+    case Op::OpGroupNonUniformQuadSwap: return "OpGroupNonUniformQuadSwap";
+    case Op::OpCopyLogical: return "OpCopyLogical";
+    case Op::OpPtrEqual: return "OpPtrEqual";
+    case Op::OpPtrNotEqual: return "OpPtrNotEqual";
+    case Op::OpPtrDiff: return "OpPtrDiff";
+    case Op::OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT";
+    case Op::OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT";
+    case Op::OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT";
+    case Op::OpTerminateInvocation: return "OpTerminateInvocation";
+    case Op::OpTypeUntypedPointerKHR: return "OpTypeUntypedPointerKHR";
+    case Op::OpUntypedVariableKHR: return "OpUntypedVariableKHR";
+    case Op::OpUntypedAccessChainKHR: return "OpUntypedAccessChainKHR";
+    case Op::OpUntypedInBoundsAccessChainKHR: return "OpUntypedInBoundsAccessChainKHR";
+    case Op::OpSubgroupBallotKHR: return "OpSubgroupBallotKHR";
+    case Op::OpSubgroupFirstInvocationKHR: return "OpSubgroupFirstInvocationKHR";
+    case Op::OpUntypedPtrAccessChainKHR: return "OpUntypedPtrAccessChainKHR";
+    case Op::OpUntypedInBoundsPtrAccessChainKHR: return "OpUntypedInBoundsPtrAccessChainKHR";
+    case Op::OpUntypedArrayLengthKHR: return "OpUntypedArrayLengthKHR";
+    case Op::OpUntypedPrefetchKHR: return "OpUntypedPrefetchKHR";
+    case Op::OpSubgroupAllKHR: return "OpSubgroupAllKHR";
+    case Op::OpSubgroupAnyKHR: return "OpSubgroupAnyKHR";
+    case Op::OpSubgroupAllEqualKHR: return "OpSubgroupAllEqualKHR";
+    case Op::OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
+    case Op::OpSubgroupReadInvocationKHR: return "OpSubgroupReadInvocationKHR";
+    case Op::OpExtInstWithForwardRefsKHR: return "OpExtInstWithForwardRefsKHR";
+    case Op::OpTraceRayKHR: return "OpTraceRayKHR";
+    case Op::OpExecuteCallableKHR: return "OpExecuteCallableKHR";
+    case Op::OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
+    case Op::OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR";
+    case Op::OpTerminateRayKHR: return "OpTerminateRayKHR";
+    case Op::OpSDot: return "OpSDot";
+    case Op::OpUDot: return "OpUDot";
+    case Op::OpSUDot: return "OpSUDot";
+    case Op::OpSDotAccSat: return "OpSDotAccSat";
+    case Op::OpUDotAccSat: return "OpUDotAccSat";
+    case Op::OpSUDotAccSat: return "OpSUDotAccSat";
+    case Op::OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR";
+    case Op::OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR";
+    case Op::OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR";
+    case Op::OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR";
+    case Op::OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR";
+    case Op::OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT";
+    case Op::OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
+    case Op::OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";
+    case Op::OpTypeRayQueryKHR: return "OpTypeRayQueryKHR";
+    case Op::OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR";
+    case Op::OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR";
+    case Op::OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR";
+    case Op::OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR";
+    case Op::OpRayQueryProceedKHR: return "OpRayQueryProceedKHR";
+    case Op::OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR";
+    case Op::OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM";
+    case Op::OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
+    case Op::OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
+    case Op::OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
+    case Op::OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM";
+    case Op::OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM";
+    case Op::OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM";
+    case Op::OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM";
+    case Op::OpGroupIAddNonUniformAMD: return "OpGroupIAddNonUniformAMD";
+    case Op::OpGroupFAddNonUniformAMD: return "OpGroupFAddNonUniformAMD";
+    case Op::OpGroupFMinNonUniformAMD: return "OpGroupFMinNonUniformAMD";
+    case Op::OpGroupUMinNonUniformAMD: return "OpGroupUMinNonUniformAMD";
+    case Op::OpGroupSMinNonUniformAMD: return "OpGroupSMinNonUniformAMD";
+    case Op::OpGroupFMaxNonUniformAMD: return "OpGroupFMaxNonUniformAMD";
+    case Op::OpGroupUMaxNonUniformAMD: return "OpGroupUMaxNonUniformAMD";
+    case Op::OpGroupSMaxNonUniformAMD: return "OpGroupSMaxNonUniformAMD";
+    case Op::OpFragmentMaskFetchAMD: return "OpFragmentMaskFetchAMD";
+    case Op::OpFragmentFetchAMD: return "OpFragmentFetchAMD";
+    case Op::OpReadClockKHR: return "OpReadClockKHR";
+    case Op::OpAllocateNodePayloadsAMDX: return "OpAllocateNodePayloadsAMDX";
+    case Op::OpEnqueueNodePayloadsAMDX: return "OpEnqueueNodePayloadsAMDX";
+    case Op::OpTypeNodePayloadArrayAMDX: return "OpTypeNodePayloadArrayAMDX";
+    case Op::OpFinishWritingNodePayloadAMDX: return "OpFinishWritingNodePayloadAMDX";
+    case Op::OpNodePayloadArrayLengthAMDX: return "OpNodePayloadArrayLengthAMDX";
+    case Op::OpIsNodePayloadValidAMDX: return "OpIsNodePayloadValidAMDX";
+    case Op::OpConstantStringAMDX: return "OpConstantStringAMDX";
+    case Op::OpSpecConstantStringAMDX: return "OpSpecConstantStringAMDX";
+    case Op::OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
+    case Op::OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
+    case Op::OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
+    case Op::OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
+    case Op::OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV";
+    case Op::OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV";
+    case Op::OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV";
+    case Op::OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV";
+    case Op::OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV";
+    case Op::OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV";
+    case Op::OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV";
+    case Op::OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
+    case Op::OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV";
+    case Op::OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV";
+    case Op::OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV";
+    case Op::OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV";
+    case Op::OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV";
+    case Op::OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV";
+    case Op::OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV";
+    case Op::OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV";
+    case Op::OpHitObjectGetHitKindNV: return "OpHitObjectGetHitKindNV";
+    case Op::OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV";
+    case Op::OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV";
+    case Op::OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV";
+    case Op::OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV";
+    case Op::OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV";
+    case Op::OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV";
+    case Op::OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV";
+    case Op::OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV";
+    case Op::OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV";
+    case Op::OpHitObjectIsHitNV: return "OpHitObjectIsHitNV";
+    case Op::OpHitObjectIsMissNV: return "OpHitObjectIsMissNV";
+    case Op::OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV";
+    case Op::OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
+    case Op::OpTypeHitObjectNV: return "OpTypeHitObjectNV";
+    case Op::OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
+    case Op::OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV";
+    case Op::OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV";
+    case Op::OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV";
+    case Op::OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV";
+    case Op::OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
+    case Op::OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
+    case Op::OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
+    case Op::OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
+    case Op::OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
+    case Op::OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
+    case Op::OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
+    case Op::OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
+    case Op::OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV";
+    case Op::OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV";
+    case Op::OpReportIntersectionKHR: return "OpReportIntersectionKHR";
+    case Op::OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
+    case Op::OpTerminateRayNV: return "OpTerminateRayNV";
+    case Op::OpTraceNV: return "OpTraceNV";
+    case Op::OpTraceMotionNV: return "OpTraceMotionNV";
+    case Op::OpTraceRayMotionNV: return "OpTraceRayMotionNV";
+    case Op::OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
+    case Op::OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR";
+    case Op::OpExecuteCallableNV: return "OpExecuteCallableNV";
+    case Op::OpRayQueryGetClusterIdNV: return "OpRayQueryGetClusterIdNV";
+    case Op::OpHitObjectGetClusterIdNV: return "OpHitObjectGetClusterIdNV";
+    case Op::OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
+    case Op::OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
+    case Op::OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV";
+    case Op::OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV";
+    case Op::OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV";
+    case Op::OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
+    case Op::OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
+    case Op::OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV";
+    case Op::OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV";
+    case Op::OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV";
+    case Op::OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
+    case Op::OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV";
+    case Op::OpTypeTensorViewNV: return "OpTypeTensorViewNV";
+    case Op::OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV";
+    case Op::OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV";
+    case Op::OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV";
+    case Op::OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV";
+    case Op::OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV";
+    case Op::OpCreateTensorViewNV: return "OpCreateTensorViewNV";
+    case Op::OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV";
+    case Op::OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV";
+    case Op::OpDemoteToHelperInvocation: return "OpDemoteToHelperInvocation";
+    case Op::OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT";
+    case Op::OpTensorViewSetClipNV: return "OpTensorViewSetClipNV";
+    case Op::OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV";
+    case Op::OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV";
+    case Op::OpConvertUToImageNV: return "OpConvertUToImageNV";
+    case Op::OpConvertUToSamplerNV: return "OpConvertUToSamplerNV";
+    case Op::OpConvertImageToUNV: return "OpConvertImageToUNV";
+    case Op::OpConvertSamplerToUNV: return "OpConvertSamplerToUNV";
+    case Op::OpConvertUToSampledImageNV: return "OpConvertUToSampledImageNV";
+    case Op::OpConvertSampledImageToUNV: return "OpConvertSampledImageToUNV";
+    case Op::OpSamplerImageAddressingModeNV: return "OpSamplerImageAddressingModeNV";
+    case Op::OpRawAccessChainNV: return "OpRawAccessChainNV";
+    case Op::OpRayQueryGetIntersectionSpherePositionNV: return "OpRayQueryGetIntersectionSpherePositionNV";
+    case Op::OpRayQueryGetIntersectionSphereRadiusNV: return "OpRayQueryGetIntersectionSphereRadiusNV";
+    case Op::OpRayQueryGetIntersectionLSSPositionsNV: return "OpRayQueryGetIntersectionLSSPositionsNV";
+    case Op::OpRayQueryGetIntersectionLSSRadiiNV: return "OpRayQueryGetIntersectionLSSRadiiNV";
+    case Op::OpRayQueryGetIntersectionLSSHitValueNV: return "OpRayQueryGetIntersectionLSSHitValueNV";
+    case Op::OpHitObjectGetSpherePositionNV: return "OpHitObjectGetSpherePositionNV";
+    case Op::OpHitObjectGetSphereRadiusNV: return "OpHitObjectGetSphereRadiusNV";
+    case Op::OpHitObjectGetLSSPositionsNV: return "OpHitObjectGetLSSPositionsNV";
+    case Op::OpHitObjectGetLSSRadiiNV: return "OpHitObjectGetLSSRadiiNV";
+    case Op::OpHitObjectIsSphereHitNV: return "OpHitObjectIsSphereHitNV";
+    case Op::OpHitObjectIsLSSHitNV: return "OpHitObjectIsLSSHitNV";
+    case Op::OpRayQueryIsSphereHitNV: return "OpRayQueryIsSphereHitNV";
+    case Op::OpRayQueryIsLSSHitNV: return "OpRayQueryIsLSSHitNV";
+    case Op::OpSubgroupShuffleINTEL: return "OpSubgroupShuffleINTEL";
+    case Op::OpSubgroupShuffleDownINTEL: return "OpSubgroupShuffleDownINTEL";
+    case Op::OpSubgroupShuffleUpINTEL: return "OpSubgroupShuffleUpINTEL";
+    case Op::OpSubgroupShuffleXorINTEL: return "OpSubgroupShuffleXorINTEL";
+    case Op::OpSubgroupBlockReadINTEL: return "OpSubgroupBlockReadINTEL";
+    case Op::OpSubgroupBlockWriteINTEL: return "OpSubgroupBlockWriteINTEL";
+    case Op::OpSubgroupImageBlockReadINTEL: return "OpSubgroupImageBlockReadINTEL";
+    case Op::OpSubgroupImageBlockWriteINTEL: return "OpSubgroupImageBlockWriteINTEL";
+    case Op::OpSubgroupImageMediaBlockReadINTEL: return "OpSubgroupImageMediaBlockReadINTEL";
+    case Op::OpSubgroupImageMediaBlockWriteINTEL: return "OpSubgroupImageMediaBlockWriteINTEL";
+    case Op::OpUCountLeadingZerosINTEL: return "OpUCountLeadingZerosINTEL";
+    case Op::OpUCountTrailingZerosINTEL: return "OpUCountTrailingZerosINTEL";
+    case Op::OpAbsISubINTEL: return "OpAbsISubINTEL";
+    case Op::OpAbsUSubINTEL: return "OpAbsUSubINTEL";
+    case Op::OpIAddSatINTEL: return "OpIAddSatINTEL";
+    case Op::OpUAddSatINTEL: return "OpUAddSatINTEL";
+    case Op::OpIAverageINTEL: return "OpIAverageINTEL";
+    case Op::OpUAverageINTEL: return "OpUAverageINTEL";
+    case Op::OpIAverageRoundedINTEL: return "OpIAverageRoundedINTEL";
+    case Op::OpUAverageRoundedINTEL: return "OpUAverageRoundedINTEL";
+    case Op::OpISubSatINTEL: return "OpISubSatINTEL";
+    case Op::OpUSubSatINTEL: return "OpUSubSatINTEL";
+    case Op::OpIMul32x16INTEL: return "OpIMul32x16INTEL";
+    case Op::OpUMul32x16INTEL: return "OpUMul32x16INTEL";
+    case Op::OpConstantFunctionPointerINTEL: return "OpConstantFunctionPointerINTEL";
+    case Op::OpFunctionPointerCallINTEL: return "OpFunctionPointerCallINTEL";
+    case Op::OpAsmTargetINTEL: return "OpAsmTargetINTEL";
+    case Op::OpAsmINTEL: return "OpAsmINTEL";
+    case Op::OpAsmCallINTEL: return "OpAsmCallINTEL";
+    case Op::OpAtomicFMinEXT: return "OpAtomicFMinEXT";
+    case Op::OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
+    case Op::OpAssumeTrueKHR: return "OpAssumeTrueKHR";
+    case Op::OpExpectKHR: return "OpExpectKHR";
+    case Op::OpDecorateString: return "OpDecorateString";
+    case Op::OpMemberDecorateString: return "OpMemberDecorateString";
+    case Op::OpVmeImageINTEL: return "OpVmeImageINTEL";
+    case Op::OpTypeVmeImageINTEL: return "OpTypeVmeImageINTEL";
+    case Op::OpTypeAvcImePayloadINTEL: return "OpTypeAvcImePayloadINTEL";
+    case Op::OpTypeAvcRefPayloadINTEL: return "OpTypeAvcRefPayloadINTEL";
+    case Op::OpTypeAvcSicPayloadINTEL: return "OpTypeAvcSicPayloadINTEL";
+    case Op::OpTypeAvcMcePayloadINTEL: return "OpTypeAvcMcePayloadINTEL";
+    case Op::OpTypeAvcMceResultINTEL: return "OpTypeAvcMceResultINTEL";
+    case Op::OpTypeAvcImeResultINTEL: return "OpTypeAvcImeResultINTEL";
+    case Op::OpTypeAvcImeResultSingleReferenceStreamoutINTEL: return "OpTypeAvcImeResultSingleReferenceStreamoutINTEL";
+    case Op::OpTypeAvcImeResultDualReferenceStreamoutINTEL: return "OpTypeAvcImeResultDualReferenceStreamoutINTEL";
+    case Op::OpTypeAvcImeSingleReferenceStreaminINTEL: return "OpTypeAvcImeSingleReferenceStreaminINTEL";
+    case Op::OpTypeAvcImeDualReferenceStreaminINTEL: return "OpTypeAvcImeDualReferenceStreaminINTEL";
+    case Op::OpTypeAvcRefResultINTEL: return "OpTypeAvcRefResultINTEL";
+    case Op::OpTypeAvcSicResultINTEL: return "OpTypeAvcSicResultINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: return "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetInterShapePenaltyINTEL: return "OpSubgroupAvcMceSetInterShapePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: return "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: return "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: return "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL";
+    case Op::OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: return "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: return "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL";
+    case Op::OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: return "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL";
+    case Op::OpSubgroupAvcMceSetAcOnlyHaarINTEL: return "OpSubgroupAvcMceSetAcOnlyHaarINTEL";
+    case Op::OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL";
+    case Op::OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: return "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL";
+    case Op::OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL";
+    case Op::OpSubgroupAvcMceConvertToImePayloadINTEL: return "OpSubgroupAvcMceConvertToImePayloadINTEL";
+    case Op::OpSubgroupAvcMceConvertToImeResultINTEL: return "OpSubgroupAvcMceConvertToImeResultINTEL";
+    case Op::OpSubgroupAvcMceConvertToRefPayloadINTEL: return "OpSubgroupAvcMceConvertToRefPayloadINTEL";
+    case Op::OpSubgroupAvcMceConvertToRefResultINTEL: return "OpSubgroupAvcMceConvertToRefResultINTEL";
+    case Op::OpSubgroupAvcMceConvertToSicPayloadINTEL: return "OpSubgroupAvcMceConvertToSicPayloadINTEL";
+    case Op::OpSubgroupAvcMceConvertToSicResultINTEL: return "OpSubgroupAvcMceConvertToSicResultINTEL";
+    case Op::OpSubgroupAvcMceGetMotionVectorsINTEL: return "OpSubgroupAvcMceGetMotionVectorsINTEL";
+    case Op::OpSubgroupAvcMceGetInterDistortionsINTEL: return "OpSubgroupAvcMceGetInterDistortionsINTEL";
+    case Op::OpSubgroupAvcMceGetBestInterDistortionsINTEL: return "OpSubgroupAvcMceGetBestInterDistortionsINTEL";
+    case Op::OpSubgroupAvcMceGetInterMajorShapeINTEL: return "OpSubgroupAvcMceGetInterMajorShapeINTEL";
+    case Op::OpSubgroupAvcMceGetInterMinorShapeINTEL: return "OpSubgroupAvcMceGetInterMinorShapeINTEL";
+    case Op::OpSubgroupAvcMceGetInterDirectionsINTEL: return "OpSubgroupAvcMceGetInterDirectionsINTEL";
+    case Op::OpSubgroupAvcMceGetInterMotionVectorCountINTEL: return "OpSubgroupAvcMceGetInterMotionVectorCountINTEL";
+    case Op::OpSubgroupAvcMceGetInterReferenceIdsINTEL: return "OpSubgroupAvcMceGetInterReferenceIdsINTEL";
+    case Op::OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: return "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL";
+    case Op::OpSubgroupAvcImeInitializeINTEL: return "OpSubgroupAvcImeInitializeINTEL";
+    case Op::OpSubgroupAvcImeSetSingleReferenceINTEL: return "OpSubgroupAvcImeSetSingleReferenceINTEL";
+    case Op::OpSubgroupAvcImeSetDualReferenceINTEL: return "OpSubgroupAvcImeSetDualReferenceINTEL";
+    case Op::OpSubgroupAvcImeRefWindowSizeINTEL: return "OpSubgroupAvcImeRefWindowSizeINTEL";
+    case Op::OpSubgroupAvcImeAdjustRefOffsetINTEL: return "OpSubgroupAvcImeAdjustRefOffsetINTEL";
+    case Op::OpSubgroupAvcImeConvertToMcePayloadINTEL: return "OpSubgroupAvcImeConvertToMcePayloadINTEL";
+    case Op::OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: return "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL";
+    case Op::OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: return "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL";
+    case Op::OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: return "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL";
+    case Op::OpSubgroupAvcImeSetWeightedSadINTEL: return "OpSubgroupAvcImeSetWeightedSadINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL";
+    case Op::OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: return "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL";
+    case Op::OpSubgroupAvcImeConvertToMceResultINTEL: return "OpSubgroupAvcImeConvertToMceResultINTEL";
+    case Op::OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: return "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeGetDualReferenceStreaminINTEL: return "OpSubgroupAvcImeGetDualReferenceStreaminINTEL";
+    case Op::OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: return "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL";
+    case Op::OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: return "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL";
+    case Op::OpSubgroupAvcImeGetBorderReachedINTEL: return "OpSubgroupAvcImeGetBorderReachedINTEL";
+    case Op::OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: return "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL";
+    case Op::OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: return "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL";
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL";
+    case Op::OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: return "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL";
+    case Op::OpSubgroupAvcFmeInitializeINTEL: return "OpSubgroupAvcFmeInitializeINTEL";
+    case Op::OpSubgroupAvcBmeInitializeINTEL: return "OpSubgroupAvcBmeInitializeINTEL";
+    case Op::OpSubgroupAvcRefConvertToMcePayloadINTEL: return "OpSubgroupAvcRefConvertToMcePayloadINTEL";
+    case Op::OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: return "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL";
+    case Op::OpSubgroupAvcRefSetBilinearFilterEnableINTEL: return "OpSubgroupAvcRefSetBilinearFilterEnableINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL";
+    case Op::OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL";
+    case Op::OpSubgroupAvcRefConvertToMceResultINTEL: return "OpSubgroupAvcRefConvertToMceResultINTEL";
+    case Op::OpSubgroupAvcSicInitializeINTEL: return "OpSubgroupAvcSicInitializeINTEL";
+    case Op::OpSubgroupAvcSicConfigureSkcINTEL: return "OpSubgroupAvcSicConfigureSkcINTEL";
+    case Op::OpSubgroupAvcSicConfigureIpeLumaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaINTEL";
+    case Op::OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: return "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL";
+    case Op::OpSubgroupAvcSicGetMotionVectorMaskINTEL: return "OpSubgroupAvcSicGetMotionVectorMaskINTEL";
+    case Op::OpSubgroupAvcSicConvertToMcePayloadINTEL: return "OpSubgroupAvcSicConvertToMcePayloadINTEL";
+    case Op::OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: return "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL";
+    case Op::OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL";
+    case Op::OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: return "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL";
+    case Op::OpSubgroupAvcSicSetBilinearFilterEnableINTEL: return "OpSubgroupAvcSicSetBilinearFilterEnableINTEL";
+    case Op::OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: return "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL";
+    case Op::OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: return "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL";
+    case Op::OpSubgroupAvcSicEvaluateIpeINTEL: return "OpSubgroupAvcSicEvaluateIpeINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL";
+    case Op::OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: return "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL";
+    case Op::OpSubgroupAvcSicConvertToMceResultINTEL: return "OpSubgroupAvcSicConvertToMceResultINTEL";
+    case Op::OpSubgroupAvcSicGetIpeLumaShapeINTEL: return "OpSubgroupAvcSicGetIpeLumaShapeINTEL";
+    case Op::OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL";
+    case Op::OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: return "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL";
+    case Op::OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: return "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL";
+    case Op::OpSubgroupAvcSicGetIpeChromaModeINTEL: return "OpSubgroupAvcSicGetIpeChromaModeINTEL";
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL";
+    case Op::OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: return "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL";
+    case Op::OpSubgroupAvcSicGetInterRawSadsINTEL: return "OpSubgroupAvcSicGetInterRawSadsINTEL";
+    case Op::OpVariableLengthArrayINTEL: return "OpVariableLengthArrayINTEL";
+    case Op::OpSaveMemoryINTEL: return "OpSaveMemoryINTEL";
+    case Op::OpRestoreMemoryINTEL: return "OpRestoreMemoryINTEL";
+    case Op::OpArbitraryFloatSinCosPiINTEL: return "OpArbitraryFloatSinCosPiINTEL";
+    case Op::OpArbitraryFloatCastINTEL: return "OpArbitraryFloatCastINTEL";
+    case Op::OpArbitraryFloatCastFromIntINTEL: return "OpArbitraryFloatCastFromIntINTEL";
+    case Op::OpArbitraryFloatCastToIntINTEL: return "OpArbitraryFloatCastToIntINTEL";
+    case Op::OpArbitraryFloatAddINTEL: return "OpArbitraryFloatAddINTEL";
+    case Op::OpArbitraryFloatSubINTEL: return "OpArbitraryFloatSubINTEL";
+    case Op::OpArbitraryFloatMulINTEL: return "OpArbitraryFloatMulINTEL";
+    case Op::OpArbitraryFloatDivINTEL: return "OpArbitraryFloatDivINTEL";
+    case Op::OpArbitraryFloatGTINTEL: return "OpArbitraryFloatGTINTEL";
+    case Op::OpArbitraryFloatGEINTEL: return "OpArbitraryFloatGEINTEL";
+    case Op::OpArbitraryFloatLTINTEL: return "OpArbitraryFloatLTINTEL";
+    case Op::OpArbitraryFloatLEINTEL: return "OpArbitraryFloatLEINTEL";
+    case Op::OpArbitraryFloatEQINTEL: return "OpArbitraryFloatEQINTEL";
+    case Op::OpArbitraryFloatRecipINTEL: return "OpArbitraryFloatRecipINTEL";
+    case Op::OpArbitraryFloatRSqrtINTEL: return "OpArbitraryFloatRSqrtINTEL";
+    case Op::OpArbitraryFloatCbrtINTEL: return "OpArbitraryFloatCbrtINTEL";
+    case Op::OpArbitraryFloatHypotINTEL: return "OpArbitraryFloatHypotINTEL";
+    case Op::OpArbitraryFloatSqrtINTEL: return "OpArbitraryFloatSqrtINTEL";
+    case Op::OpArbitraryFloatLogINTEL: return "OpArbitraryFloatLogINTEL";
+    case Op::OpArbitraryFloatLog2INTEL: return "OpArbitraryFloatLog2INTEL";
+    case Op::OpArbitraryFloatLog10INTEL: return "OpArbitraryFloatLog10INTEL";
+    case Op::OpArbitraryFloatLog1pINTEL: return "OpArbitraryFloatLog1pINTEL";
+    case Op::OpArbitraryFloatExpINTEL: return "OpArbitraryFloatExpINTEL";
+    case Op::OpArbitraryFloatExp2INTEL: return "OpArbitraryFloatExp2INTEL";
+    case Op::OpArbitraryFloatExp10INTEL: return "OpArbitraryFloatExp10INTEL";
+    case Op::OpArbitraryFloatExpm1INTEL: return "OpArbitraryFloatExpm1INTEL";
+    case Op::OpArbitraryFloatSinINTEL: return "OpArbitraryFloatSinINTEL";
+    case Op::OpArbitraryFloatCosINTEL: return "OpArbitraryFloatCosINTEL";
+    case Op::OpArbitraryFloatSinCosINTEL: return "OpArbitraryFloatSinCosINTEL";
+    case Op::OpArbitraryFloatSinPiINTEL: return "OpArbitraryFloatSinPiINTEL";
+    case Op::OpArbitraryFloatCosPiINTEL: return "OpArbitraryFloatCosPiINTEL";
+    case Op::OpArbitraryFloatASinINTEL: return "OpArbitraryFloatASinINTEL";
+    case Op::OpArbitraryFloatASinPiINTEL: return "OpArbitraryFloatASinPiINTEL";
+    case Op::OpArbitraryFloatACosINTEL: return "OpArbitraryFloatACosINTEL";
+    case Op::OpArbitraryFloatACosPiINTEL: return "OpArbitraryFloatACosPiINTEL";
+    case Op::OpArbitraryFloatATanINTEL: return "OpArbitraryFloatATanINTEL";
+    case Op::OpArbitraryFloatATanPiINTEL: return "OpArbitraryFloatATanPiINTEL";
+    case Op::OpArbitraryFloatATan2INTEL: return "OpArbitraryFloatATan2INTEL";
+    case Op::OpArbitraryFloatPowINTEL: return "OpArbitraryFloatPowINTEL";
+    case Op::OpArbitraryFloatPowRINTEL: return "OpArbitraryFloatPowRINTEL";
+    case Op::OpArbitraryFloatPowNINTEL: return "OpArbitraryFloatPowNINTEL";
+    case Op::OpLoopControlINTEL: return "OpLoopControlINTEL";
+    case Op::OpAliasDomainDeclINTEL: return "OpAliasDomainDeclINTEL";
+    case Op::OpAliasScopeDeclINTEL: return "OpAliasScopeDeclINTEL";
+    case Op::OpAliasScopeListDeclINTEL: return "OpAliasScopeListDeclINTEL";
+    case Op::OpFixedSqrtINTEL: return "OpFixedSqrtINTEL";
+    case Op::OpFixedRecipINTEL: return "OpFixedRecipINTEL";
+    case Op::OpFixedRsqrtINTEL: return "OpFixedRsqrtINTEL";
+    case Op::OpFixedSinINTEL: return "OpFixedSinINTEL";
+    case Op::OpFixedCosINTEL: return "OpFixedCosINTEL";
+    case Op::OpFixedSinCosINTEL: return "OpFixedSinCosINTEL";
+    case Op::OpFixedSinPiINTEL: return "OpFixedSinPiINTEL";
+    case Op::OpFixedCosPiINTEL: return "OpFixedCosPiINTEL";
+    case Op::OpFixedSinCosPiINTEL: return "OpFixedSinCosPiINTEL";
+    case Op::OpFixedLogINTEL: return "OpFixedLogINTEL";
+    case Op::OpFixedExpINTEL: return "OpFixedExpINTEL";
+    case Op::OpPtrCastToCrossWorkgroupINTEL: return "OpPtrCastToCrossWorkgroupINTEL";
+    case Op::OpCrossWorkgroupCastToPtrINTEL: return "OpCrossWorkgroupCastToPtrINTEL";
+    case Op::OpReadPipeBlockingINTEL: return "OpReadPipeBlockingINTEL";
+    case Op::OpWritePipeBlockingINTEL: return "OpWritePipeBlockingINTEL";
+    case Op::OpFPGARegINTEL: return "OpFPGARegINTEL";
+    case Op::OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR";
+    case Op::OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR";
+    case Op::OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR";
+    case Op::OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
+    case Op::OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR";
+    case Op::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
+    case Op::OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR";
+    case Op::OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
+    case Op::OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR";
+    case Op::OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR";
+    case Op::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
+    case Op::OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
+    case Op::OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR";
+    case Op::OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR";
+    case Op::OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR";
+    case Op::OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR";
+    case Op::OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR";
+    case Op::OpAtomicFAddEXT: return "OpAtomicFAddEXT";
+    case Op::OpTypeBufferSurfaceINTEL: return "OpTypeBufferSurfaceINTEL";
+    case Op::OpTypeStructContinuedINTEL: return "OpTypeStructContinuedINTEL";
+    case Op::OpConstantCompositeContinuedINTEL: return "OpConstantCompositeContinuedINTEL";
+    case Op::OpSpecConstantCompositeContinuedINTEL: return "OpSpecConstantCompositeContinuedINTEL";
+    case Op::OpCompositeConstructContinuedINTEL: return "OpCompositeConstructContinuedINTEL";
+    case Op::OpConvertFToBF16INTEL: return "OpConvertFToBF16INTEL";
+    case Op::OpConvertBF16ToFINTEL: return "OpConvertBF16ToFINTEL";
+    case Op::OpControlBarrierArriveINTEL: return "OpControlBarrierArriveINTEL";
+    case Op::OpControlBarrierWaitINTEL: return "OpControlBarrierWaitINTEL";
+    case Op::OpArithmeticFenceEXT: return "OpArithmeticFenceEXT";
+    case Op::OpSubgroupBlockPrefetchINTEL: return "OpSubgroupBlockPrefetchINTEL";
+    case Op::OpSubgroup2DBlockLoadINTEL: return "OpSubgroup2DBlockLoadINTEL";
+    case Op::OpSubgroup2DBlockLoadTransformINTEL: return "OpSubgroup2DBlockLoadTransformINTEL";
+    case Op::OpSubgroup2DBlockLoadTransposeINTEL: return "OpSubgroup2DBlockLoadTransposeINTEL";
+    case Op::OpSubgroup2DBlockPrefetchINTEL: return "OpSubgroup2DBlockPrefetchINTEL";
+    case Op::OpSubgroup2DBlockStoreINTEL: return "OpSubgroup2DBlockStoreINTEL";
+    case Op::OpSubgroupMatrixMultiplyAccumulateINTEL: return "OpSubgroupMatrixMultiplyAccumulateINTEL";
+    case Op::OpGroupIMulKHR: return "OpGroupIMulKHR";
+    case Op::OpGroupFMulKHR: return "OpGroupFMulKHR";
+    case Op::OpGroupBitwiseAndKHR: return "OpGroupBitwiseAndKHR";
+    case Op::OpGroupBitwiseOrKHR: return "OpGroupBitwiseOrKHR";
+    case Op::OpGroupBitwiseXorKHR: return "OpGroupBitwiseXorKHR";
+    case Op::OpGroupLogicalAndKHR: return "OpGroupLogicalAndKHR";
+    case Op::OpGroupLogicalOrKHR: return "OpGroupLogicalOrKHR";
+    case Op::OpGroupLogicalXorKHR: return "OpGroupLogicalXorKHR";
+    case Op::OpMaskedGatherINTEL: return "OpMaskedGatherINTEL";
+    case Op::OpMaskedScatterINTEL: return "OpMaskedScatterINTEL";
+    default: return "Unknown";
+    }
+}
+
+#endif /* SPV_ENABLE_UTILITY_CODE */
+
+// Overload bitwise operators for mask bit combining
+
+constexpr ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr ImageOperandsMask operator&(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr ImageOperandsMask operator^(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr ImageOperandsMask operator~(ImageOperandsMask a) { return ImageOperandsMask(~unsigned(a)); }
+constexpr FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
+constexpr FPFastMathModeMask operator&(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) & unsigned(b)); }
+constexpr FPFastMathModeMask operator^(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) ^ unsigned(b)); }
+constexpr FPFastMathModeMask operator~(FPFastMathModeMask a) { return FPFastMathModeMask(~unsigned(a)); }
+constexpr SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
+constexpr SelectionControlMask operator&(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) & unsigned(b)); }
+constexpr SelectionControlMask operator^(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) ^ unsigned(b)); }
+constexpr SelectionControlMask operator~(SelectionControlMask a) { return SelectionControlMask(~unsigned(a)); }
+constexpr LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
+constexpr LoopControlMask operator&(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) & unsigned(b)); }
+constexpr LoopControlMask operator^(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) ^ unsigned(b)); }
+constexpr LoopControlMask operator~(LoopControlMask a) { return LoopControlMask(~unsigned(a)); }
+constexpr FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
+constexpr FunctionControlMask operator&(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) & unsigned(b)); }
+constexpr FunctionControlMask operator^(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) ^ unsigned(b)); }
+constexpr FunctionControlMask operator~(FunctionControlMask a) { return FunctionControlMask(~unsigned(a)); }
+constexpr MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
+constexpr MemorySemanticsMask operator&(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) & unsigned(b)); }
+constexpr MemorySemanticsMask operator^(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) ^ unsigned(b)); }
+constexpr MemorySemanticsMask operator~(MemorySemanticsMask a) { return MemorySemanticsMask(~unsigned(a)); }
+constexpr MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
+constexpr MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) & unsigned(b)); }
+constexpr MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) ^ unsigned(b)); }
+constexpr MemoryAccessMask operator~(MemoryAccessMask a) { return MemoryAccessMask(~unsigned(a)); }
+constexpr KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
+constexpr KernelProfilingInfoMask operator&(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) & unsigned(b)); }
+constexpr KernelProfilingInfoMask operator^(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b)); }
+constexpr KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) { return KernelProfilingInfoMask(~unsigned(a)); }
+constexpr RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
+constexpr RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) & unsigned(b)); }
+constexpr RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) ^ unsigned(b)); }
+constexpr RayFlagsMask operator~(RayFlagsMask a) { return RayFlagsMask(~unsigned(a)); }
+constexpr FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
+constexpr FragmentShadingRateMask operator&(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) & unsigned(b)); }
+constexpr FragmentShadingRateMask operator^(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) ^ unsigned(b)); }
+constexpr FragmentShadingRateMask operator~(FragmentShadingRateMask a) { return FragmentShadingRateMask(~unsigned(a)); }
+constexpr CooperativeMatrixOperandsMask operator|(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr CooperativeMatrixOperandsMask operator&(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr CooperativeMatrixOperandsMask operator^(CooperativeMatrixOperandsMask a, CooperativeMatrixOperandsMask b) { return CooperativeMatrixOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr CooperativeMatrixOperandsMask operator~(CooperativeMatrixOperandsMask a) { return CooperativeMatrixOperandsMask(~unsigned(a)); }
+constexpr CooperativeMatrixReduceMask operator|(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) | unsigned(b)); }
+constexpr CooperativeMatrixReduceMask operator&(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) & unsigned(b)); }
+constexpr CooperativeMatrixReduceMask operator^(CooperativeMatrixReduceMask a, CooperativeMatrixReduceMask b) { return CooperativeMatrixReduceMask(unsigned(a) ^ unsigned(b)); }
+constexpr CooperativeMatrixReduceMask operator~(CooperativeMatrixReduceMask a) { return CooperativeMatrixReduceMask(~unsigned(a)); }
+constexpr TensorAddressingOperandsMask operator|(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr TensorAddressingOperandsMask operator&(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr TensorAddressingOperandsMask operator^(TensorAddressingOperandsMask a, TensorAddressingOperandsMask b) { return TensorAddressingOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr TensorAddressingOperandsMask operator~(TensorAddressingOperandsMask a) { return TensorAddressingOperandsMask(~unsigned(a)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator|(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator&(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator^(MatrixMultiplyAccumulateOperandsMask a, MatrixMultiplyAccumulateOperandsMask b) { return MatrixMultiplyAccumulateOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr MatrixMultiplyAccumulateOperandsMask operator~(MatrixMultiplyAccumulateOperandsMask a) { return MatrixMultiplyAccumulateOperandsMask(~unsigned(a)); }
+constexpr RawAccessChainOperandsMask operator|(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) | unsigned(b)); }
+constexpr RawAccessChainOperandsMask operator&(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) & unsigned(b)); }
+constexpr RawAccessChainOperandsMask operator^(RawAccessChainOperandsMask a, RawAccessChainOperandsMask b) { return RawAccessChainOperandsMask(unsigned(a) ^ unsigned(b)); }
+constexpr RawAccessChainOperandsMask operator~(RawAccessChainOperandsMask a) { return RawAccessChainOperandsMask(~unsigned(a)); }
+
+}  // end namespace spv
+
+#endif  // #ifndef spirv_HPP
+

+ 106 - 32
src/libraries/glslang/SPIRV/spvIR.h

@@ -47,7 +47,7 @@
 #ifndef spvIR_H
 #define spvIR_H
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 #include <algorithm>
 #include <cassert>
@@ -67,7 +67,7 @@ class Module;
 const Id NoResult = 0;
 const Id NoType = 0;
 
-const Decoration NoPrecision = DecorationMax;
+const Decoration NoPrecision = Decoration::Max;
 
 #ifdef __GNUC__
 #   define POTENTIALLY_UNUSED __attribute__((unused))
@@ -77,15 +77,19 @@ const Decoration NoPrecision = DecorationMax;
 
 POTENTIALLY_UNUSED
 const MemorySemanticsMask MemorySemanticsAllMemory =
-                (MemorySemanticsMask)(MemorySemanticsUniformMemoryMask |
-                                      MemorySemanticsWorkgroupMemoryMask |
-                                      MemorySemanticsAtomicCounterMemoryMask |
-                                      MemorySemanticsImageMemoryMask);
+                (MemorySemanticsMask)(MemorySemanticsMask::UniformMemory |
+                                      MemorySemanticsMask::WorkgroupMemory |
+                                      MemorySemanticsMask::AtomicCounterMemory | 
+                                      MemorySemanticsMask::ImageMemory);
 
 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) {}
+    IdImmediate(bool i, spv::MemoryAccessMask w) : isId(i), word((unsigned)w) {}
+    IdImmediate(bool i, spv::TensorAddressingOperandsMask w) : isId(i), word((unsigned)w) {}
+    IdImmediate(bool i, spv::ImageOperandsMask w) : isId(i), word((unsigned)w) {}
+    IdImmediate(bool i, spv::CooperativeMatrixOperandsMask w) : isId(i), word((unsigned)w) {}
 };
 
 //
@@ -119,6 +123,67 @@ public:
         operands.push_back(immediate);
         idOperand.push_back(false);
     }
+
+    void addImmediateOperand(spv::StorageClass immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::ExecutionMode immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::ExecutionModel immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::Decoration immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::LinkageType immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::MemoryAccessMask immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::Capability immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::AddressingModel immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::MemoryModel immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::FPEncoding immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::SourceLanguage immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::Dim immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::FunctionControlMask immediate){
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::SelectionControlMask immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
+    void addImmediateOperand(spv::LoopControlMask immediate) {
+        addImmediateOperand((unsigned)immediate);
+    }
+
     void setImmediateOperand(unsigned idx, unsigned int immediate) {
         assert(!idOperand[idx]);
         operands[idx] = immediate;
@@ -128,7 +193,7 @@ public:
     {
         unsigned int word = 0;
         unsigned int shiftAmount = 0;
-        char c;
+        unsigned char c;
 
         do {
             c = *(str++);
@@ -178,7 +243,7 @@ public:
         wordCount += (unsigned int)operands.size();
 
         // Write out the beginning of the instruction
-        out.push_back(((wordCount) << WordCountShift) | opCode);
+        out.push_back(((wordCount) << WordCountShift) | (unsigned)opCode);
         if (typeId)
             out.push_back(typeId);
         if (resultId)
@@ -189,6 +254,15 @@ public:
             out.push_back(operands[op]);
     }
 
+    const char *getNameString() const {
+        if (opCode == Op::OpString) {
+            return (const char *)&operands[0];
+        } else {
+            assert(opCode == Op::OpName);
+            return (const char *)&operands[1];
+        }
+    }
+
 protected:
     Instruction(const Instruction&);
     Id resultId;
@@ -257,8 +331,8 @@ public:
         if (instructions.size() < 2) return nullptr;
         const Instruction* nextToLast = (instructions.cend() - 2)->get();
         switch (nextToLast->getOpCode()) {
-            case OpSelectionMerge:
-            case OpLoopMerge:
+            case Op::OpSelectionMerge:
+            case Op::OpLoopMerge:
                 return nextToLast;
             default:
                 return nullptr;
@@ -275,7 +349,7 @@ public:
         assert(instructions.size() > 0);
         instructions.resize(1);
         successors.clear();
-        addInstruction(std::unique_ptr<Instruction>(new Instruction(OpUnreachable)));
+        addInstruction(std::unique_ptr<Instruction>(new Instruction(Op::OpUnreachable)));
     }
     // Change this block into a canonical dead continue target branching to the
     // given header ID.  Delete instructions as necessary.  A canonical dead continue
@@ -289,7 +363,7 @@ public:
         successors.clear();
         // Add OpBranch back to the header.
         assert(header != nullptr);
-        Instruction* branch = new Instruction(OpBranch);
+        Instruction* branch = new Instruction(Op::OpBranch);
         branch->addIdOperand(header->getId());
         addInstruction(std::unique_ptr<Instruction>(branch));
         successors.push_back(header);
@@ -298,14 +372,14 @@ public:
     bool isTerminated() const
     {
         switch (instructions.back()->getOpCode()) {
-        case OpBranch:
-        case OpBranchConditional:
-        case OpSwitch:
-        case OpKill:
-        case OpTerminateInvocation:
-        case OpReturn:
-        case OpReturnValue:
-        case OpUnreachable:
+        case Op::OpBranch:
+        case Op::OpBranchConditional:
+        case Op::OpSwitch:
+        case Op::OpKill:
+        case Op::OpTerminateInvocation:
+        case Op::OpReturn:
+        case Op::OpReturnValue:
+        case Op::OpUnreachable:
             return true;
         default:
             return false;
@@ -402,14 +476,14 @@ public:
     Id getFuncTypeId() const { return functionInstruction.getIdOperand(1); }
     void setReturnPrecision(Decoration precision)
     {
-        if (precision == DecorationRelaxedPrecision)
+        if (precision == Decoration::RelaxedPrecision)
             reducedPrecisionReturn = true;
     }
     Decoration getReturnPrecision() const
-        { return reducedPrecisionReturn ? DecorationRelaxedPrecision : NoPrecision; }
+        { return reducedPrecisionReturn ? Decoration::RelaxedPrecision : NoPrecision; }
 
     void setDebugLineInfo(Id fileName, int line, int column) {
-        lineInstruction = std::unique_ptr<Instruction>{new Instruction(OpLine)};
+        lineInstruction = std::unique_ptr<Instruction>{new Instruction(Op::OpLine)};
         lineInstruction->reserveOperands(3);
         lineInstruction->addIdOperand(fileName);
         lineInstruction->addImmediateOperand(line);
@@ -422,13 +496,13 @@ public:
 
     void addParamPrecision(unsigned param, Decoration precision)
     {
-        if (precision == DecorationRelaxedPrecision)
+        if (precision == Decoration::RelaxedPrecision)
             reducedPrecisionParams.insert(param);
     }
     Decoration getParamPrecision(unsigned param) const
     {
         return reducedPrecisionParams.find(param) != reducedPrecisionParams.end() ?
-            DecorationRelaxedPrecision : NoPrecision;
+            Decoration::RelaxedPrecision : NoPrecision;
     }
 
     void dump(std::vector<unsigned int>& out) const
@@ -447,7 +521,7 @@ public:
 
         // Blocks
         inReadableOrder(blocks[0], [&out](const Block* b, ReachReason, Block*) { b->dump(out); });
-        Instruction end(0, 0, OpFunctionEnd);
+        Instruction end(0, 0, Op::OpFunctionEnd);
         end.dump(out);
     }
 
@@ -500,7 +574,7 @@ public:
     }
     StorageClass getStorageClass(Id typeId) const
     {
-        assert(idToInstruction[typeId]->getOpCode() == spv::OpTypePointer);
+        assert(idToInstruction[typeId]->getOpCode() == spv::Op::OpTypePointer);
         return (StorageClass)idToInstruction[typeId]->getImmediateOperand(0);
     }
 
@@ -529,13 +603,13 @@ protected:
 // - all the OpFunctionParameter instructions
 __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, LinkageType linkage, const std::string& name, Module& parent)
     : parent(parent), lineInstruction(nullptr),
-      functionInstruction(id, resultType, OpFunction), implicitThis(false),
+      functionInstruction(id, resultType, Op::OpFunction), implicitThis(false),
       reducedPrecisionReturn(false),
       linkType(linkage)
 {
     // OpFunction
     functionInstruction.reserveOperands(2);
-    functionInstruction.addImmediateOperand(FunctionControlMaskNone);
+    functionInstruction.addImmediateOperand(FunctionControlMask::MaskNone);
     functionInstruction.addIdOperand(functionType);
     parent.mapInstruction(&functionInstruction);
     parent.addFunction(this);
@@ -544,13 +618,13 @@ __inline Function::Function(Id id, Id resultType, Id functionType, Id firstParam
     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);
+        Instruction* param = new Instruction(firstParamId + p, typeInst->getIdOperand(p + 1), Op::OpFunctionParameter);
         parent.mapInstruction(param);
         parameterInstructions.push_back(param);
     }
 
     // If importing/exporting, save the function name (without the mangled parameters) for the linkage decoration
-    if (linkType != LinkageTypeMax) {
+    if (linkType != LinkageType::Max) {
         exportName = name.substr(0, name.find_first_of('('));
     }
 }
@@ -564,7 +638,7 @@ __inline void Function::addLocalVariable(std::unique_ptr<Instruction> inst)
 
 __inline Block::Block(Id id, Function& parent) : parent(parent), unreachable(false)
 {
-    instructions.push_back(std::unique_ptr<Instruction>(new Instruction(id, NoType, OpLabel)));
+    instructions.push_back(std::unique_ptr<Instruction>(new Instruction(id, NoType, Op::OpLabel)));
     instructions.back()->setBlock(this);
     parent.getParent().mapInstruction(instructions.back().get());
 }

+ 88 - 0
src/libraries/glslang/SPIRV/spvUtil.h

@@ -0,0 +1,88 @@
+//
+// Copyright (C) 2025 Jan Kelemen
+//
+// 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
+#ifndef spvUtil_H
+#define spvUtil_H
+
+#include <cstdint>
+#include <type_traits>
+
+#include "spirv.hpp11"
+
+namespace spv {
+__inline uint32_t operator&(uint32_t value, spv::MemoryAccessMask mask) { return value & (unsigned)mask; }
+
+__inline bool operator==(uint32_t word, spv::FPEncoding encoding) { return word == (unsigned)encoding; }
+__inline bool operator!=(uint32_t word, spv::FPEncoding encoding) { return !(word == encoding); }
+
+__inline bool operator==(uint32_t word, spv::Decoration decoration) { return word == (unsigned)decoration; }
+__inline bool operator!=(uint32_t word, spv::Decoration decoration) { return !(word == decoration); }
+
+__inline bool operator==(uint32_t word, spv::Op op) { return word == (unsigned)op; }
+__inline bool operator!=(uint32_t word, spv::Op op) { return !(word == op); }
+
+__inline bool operator==(uint32_t word, spv::StorageClass storage) { return word == (unsigned)storage; }
+__inline bool operator!=(uint32_t word, spv::StorageClass storage) { return !(word == storage); }
+
+__inline bool anySet(spv::MemoryAccessMask value, spv::MemoryAccessMask mask)
+{
+    return (value & mask) != spv::MemoryAccessMask::MaskNone;
+}
+
+__inline bool anySet(spv::ImageOperandsMask value, spv::ImageOperandsMask mask)
+{
+    return (value & mask) != spv::ImageOperandsMask::MaskNone;
+}
+
+__inline bool anySet(spv::MemorySemanticsMask value, spv::MemorySemanticsMask mask)
+{
+    return (value & mask) != spv::MemorySemanticsMask::MaskNone;
+}
+
+__inline void addMask(uint32_t& word, spv::TensorAddressingOperandsMask mask) { word |= (unsigned)mask; }
+
+__inline void addMask(spv::CooperativeMatrixOperandsMask& word, spv::CooperativeMatrixOperandsMask mask)
+{
+    word = word | mask;
+}
+
+template<typename Enum, typename To = std::underlying_type_t<Enum>>
+__inline To enumCast(Enum value)
+{
+    return static_cast<To>(value);
+}
+}
+
+#endif // spvUtil_H

+ 58 - 0
src/libraries/glslang/glslang/Include/BaseTypes.h

@@ -49,6 +49,9 @@ enum TBasicType {
     EbtFloat,
     EbtDouble,
     EbtFloat16,
+    EbtBFloat16,
+    EbtFloatE5M2,
+    EbtFloatE4M3,
     EbtInt8,
     EbtUint8,
     EbtInt16,
@@ -67,6 +70,10 @@ enum TBasicType {
     EbtRayQuery,
     EbtHitObjectNV,
     EbtCoopmat,
+    EbtFunction,
+    EbtTensorLayoutNV,
+    EbtTensorViewNV,
+    EbtCoopvecNV,
     // SPIR-V type defined by spirv_type
     EbtSpirvType,
 
@@ -275,6 +282,7 @@ enum TBuiltInVariable {
     EbvWorldToObject3x4,
     EbvIncomingRayFlags,
     EbvCurrentRayTimeNV,
+    EbvClusterIDNV,
     // barycentrics
     EbvBaryCoordNV,
     EbvBaryCoordNoPerspNV,
@@ -295,6 +303,13 @@ enum TBuiltInVariable {
     EbvHitKindFrontFacingMicroTriangleNV,
     EbvHitKindBackFacingMicroTriangleNV,
 
+    EbvHitIsSphereNV,
+    EbvHitIsLSSNV,
+    EbvHitSpherePositionNV,
+    EbvHitSphereRadiusNV,
+    EbvHitLSSPositionsNV,
+    EbvHitLSSRadiiNV,
+
     //GL_EXT_mesh_shader
     EbvPrimitivePointIndicesEXT,
     EbvPrimitiveLineIndicesEXT,
@@ -331,6 +346,11 @@ enum TBuiltInVariable {
 
     EbvPositionFetch,
 
+    // SPV_QCOM_tile_shading
+    EbvTileOffsetQCOM,
+    EbvTileDimensionQCOM,
+    EbvTileApronSizeQCOM,
+
     EbvLast
 };
 
@@ -499,6 +519,7 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
     case EbvObjectToWorld:              return "ObjectToWorldNV";
     case EbvWorldToObject:              return "WorldToObjectNV";
     case EbvCurrentRayTimeNV:           return "CurrentRayTimeNV";
+    case EbvClusterIDNV:                return "ClusterIDNV";
 
     case EbvBaryCoordEXT:
     case EbvBaryCoordNV:                return "BaryCoordKHR";
@@ -530,6 +551,13 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
     case EbvHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
     case EbvHitKindBackFacingMicroTriangleNV:  return "HitKindBackFacingMicroTriangleNV";
 
+    case EbvHitIsSphereNV:              return "HitIsSphereNV";
+    case EbvHitIsLSSNV:                 return "HitIsLSSNV";
+    case EbvHitSpherePositionNV:        return "HitSpherePositionNV";
+    case EbvHitSphereRadiusNV:          return "HitSphereRadiusNV";
+    case EbvHitLSSPositionsNV:          return "HitSpherePositionsNV";
+    case EbvHitLSSRadiiNV:              return "HitLSSRadiiNV";
+
     default:                      return "unknown built-in variable";
     }
 }
@@ -582,12 +610,42 @@ __inline bool isTypeFloat(TBasicType type)
     case EbtFloat:
     case EbtDouble:
     case EbtFloat16:
+    case EbtBFloat16:
+    case EbtFloatE5M2:
+    case EbtFloatE4M3:
         return true;
     default:
         return false;
     }
 }
 
+__inline uint32_t GetNumBits(TBasicType type)
+{
+    switch (type) {
+    case EbtInt8:
+    case EbtUint8:
+    case EbtFloatE5M2:
+    case EbtFloatE4M3:
+        return 8;
+    case EbtBFloat16:
+    case EbtFloat16:
+    case EbtInt16:
+    case EbtUint16:
+        return 16;
+    case EbtInt:
+    case EbtUint:
+    case EbtFloat:
+        return 32;
+    case EbtDouble:
+    case EbtInt64:
+    case EbtUint64:
+        return 64;
+    default:
+        assert(false);
+        return 0;
+    }
+}
+
 __inline int getTypeRank(TBasicType type)
 {
     int res = -1;

+ 5 - 0
src/libraries/glslang/glslang/Include/PoolAlloc.h

@@ -61,6 +61,8 @@
 // class as the allocator (second) template argument.
 //
 
+#include "visibility.h"
+
 #include <cstddef>
 #include <cstring>
 #include <vector>
@@ -179,6 +181,7 @@ public:
     // Call allocate() to actually acquire memory.  Returns nullptr if no memory
     // available, otherwise a properly aligned pointer to 'numBytes' of memory.
     //
+    GLSLANG_EXPORT_FOR_TESTS
     void* allocate(size_t numBytes);
 
     //
@@ -255,6 +258,7 @@ private:
 // different times.  But a simple use is to have a global pop
 // with everyone using the same global allocator.
 //
+GLSLANG_EXPORT_FOR_TESTS
 extern TPoolAllocator& GetThreadPoolAllocator();
 void SetThreadPoolAllocator(TPoolAllocator* poolAllocator);
 
@@ -289,6 +293,7 @@ public:
     template<class Other>
         pool_allocator(const pool_allocator<Other>& p) : allocator(p.getAllocator()) { }
 
+    GLSLANG_EXPORT_FOR_TESTS
     pointer allocate(size_type n) {
         return reinterpret_cast<pointer>(getAllocator().allocate(n * sizeof(T))); }
     pointer allocate(size_type n, const void*) {

+ 182 - 51
src/libraries/glslang/glslang/Include/Types.h

@@ -85,6 +85,7 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
     bool      image : 1;  // image, combined should be false
     bool   combined : 1;  // true means texture is combined with a sampler, false means texture with no sampler
     bool    sampler : 1;  // true means a pure sampler, other fields should be clear()
+    bool   tileQCOM : 1;  // is tile shading attachment 
 
     unsigned int vectorSize : 3;  // vector return type size.
     // Some languages support structures as sample results.  Storing the whole structure in the
@@ -127,6 +128,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
     bool isShadow()      const { return shadow; }
     bool isArrayed()     const { return arrayed; }
 
+    bool isTileAttachmentQCOM() const { return tileQCOM; }
+
     void clear()
     {
         type = EbtVoid;
@@ -139,6 +142,7 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
         sampler = false;
         external = false;
         yuv = false;
+        tileQCOM = false;
 
 #ifdef ENABLE_HLSL
         clearReturnStruct();
@@ -220,7 +224,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
             isCombined() == right.isCombined() &&
          isPureSampler() == right.isPureSampler() &&
             isExternal() == right.isExternal() &&
-                 isYuv() == right.isYuv()
+                 isYuv() == right.isYuv() &&
+  isTileAttachmentQCOM() == right.isTileAttachmentQCOM()
 #ifdef ENABLE_HLSL
       && getVectorSize() == right.getVectorSize() &&
   getStructReturnIndex() == right.getStructReturnIndex()
@@ -246,6 +251,9 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
         case EbtInt:    s.append("i");   break;
         case EbtUint:   s.append("u");   break;
         case EbtFloat16: s.append("f16"); break;
+        case EbtBFloat16: s.append("bf16"); break;
+        case EbtFloatE5M2: s.append("fe5m2"); break;
+        case EbtFloatE4M3: s.append("fe4m3"); break;
         case EbtInt8:   s.append("i8");  break;
         case EbtUint16: s.append("u8");  break;
         case EbtInt16:  s.append("i16"); break;
@@ -259,6 +267,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
                 s.append("attachmentEXT");
             else if (isSubpass())
                 s.append("subpass");
+            else if (isTileAttachmentQCOM())
+                s.append("attachmentQCOM");
             else
                 s.append("image");
         } else if (isCombined()) {
@@ -307,21 +317,6 @@ typedef TVector<TTypeLoc> TTypeList;
 
 typedef TVector<TString*> TIdentifierList;
 
-//
-// Following are a series of helper enums for managing layouts and qualifiers,
-// used for TPublicType, TType, others.
-//
-
-enum TLayoutPacking {
-    ElpNone,
-    ElpShared,      // default, but different than saying nothing
-    ElpStd140,
-    ElpStd430,
-    ElpPacked,
-    ElpScalar,
-    ElpCount        // If expanding, see bitfield width below
-};
-
 enum TLayoutMatrix {
     ElmNone,
     ElmRowMajor,
@@ -567,6 +562,7 @@ public:
         shadercallcoherent = false;
         nonprivate = false;
         volatil      = false;
+        nontemporal = false;
         restrict     = false;
         readonly     = false;
         writeonly    = false;
@@ -604,6 +600,7 @@ public:
     bool writeonly    : 1;
     bool coherent     : 1;
     bool volatil      : 1;
+    bool nontemporal  : 1;
     bool devicecoherent : 1;
     bool queuefamilycoherent : 1;
     bool workgroupcoherent : 1;
@@ -618,14 +615,15 @@ public:
     bool isRestrict() const { return restrict; }
     bool isCoherent() const { return coherent; }
     bool isVolatile() const { return volatil; }
+    bool isNonTemporal() const { return nontemporal; }
     bool isSample() const { return sample; }
     bool isMemory() const
     {
-        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly || nonprivate;
+        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || nontemporal || restrict || readonly || writeonly || nonprivate;
     }
     bool isMemoryQualifierImageAndSSBOOnly() const
     {
-        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly;
+        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || nontemporal || restrict || readonly || writeonly;
     }
     bool bufferReferenceNeedsVulkanMemoryModel() const
     {
@@ -861,6 +859,8 @@ public:
         layoutBufferReferenceAlign = layoutBufferReferenceAlignEnd;
         layoutFormat = ElfNone;
 
+        layoutTileAttachmentQCOM = false;
+
         clearInterstageLayout();
 
         layoutSpecConstantId = layoutSpecConstantIdEnd;
@@ -962,6 +962,8 @@ public:
     bool layoutBindlessSampler;
     bool layoutBindlessImage;
 
+    bool layoutTileAttachmentQCOM;
+
     bool hasUniformLayout() const
     {
         return hasMatrix() ||
@@ -1080,6 +1082,10 @@ public:
     {
         return layoutBindlessImage;
     }
+    bool isTileAttachmentQCOM() const
+    {
+        return layoutTileAttachmentQCOM;
+    }
 
     // GL_EXT_spirv_intrinsics
     bool hasSpirvDecorate() const { return spirvDecorate != nullptr; }
@@ -1293,7 +1299,7 @@ public:
     }
 };
 
-// Qualifiers that don't need to be keep per object.  They have shader scope, not object scope.
+// Qualifiers that don't need to be kept per object.  They have shader scope, not object scope.
 // So, they will not be part of TType, TQualifier, etc.
 struct TShaderQualifiers {
     TLayoutGeometry geometry; // geometry/tessellation shader in/out primitives
@@ -1323,6 +1329,9 @@ struct TShaderQualifiers {
     bool layoutDerivativeGroupLinear;   // true if layout derivative_group_linearNV set
     int primitives;                     // mesh shader "max_primitives"DerivativeGroupLinear;   // true if layout derivative_group_linearNV set
     bool layoutPrimitiveCulling;        // true if layout primitive_culling set
+    bool layoutNonCoherentTileAttachmentReadQCOM; // fragment shaders -- per object
+    int  layoutTileShadingRateQCOM[3];  // compute shader
+    bool layoutTileShadingRateQCOMNotDefault[3];  // compute shader
     TLayoutDepth getDepth() const { return layoutDepth; }
     TLayoutStencil getStencil() const { return layoutStencil; }
 
@@ -1359,6 +1368,13 @@ struct TShaderQualifiers {
         layoutDerivativeGroupQuads  = false;
         layoutDerivativeGroupLinear = false;
         layoutPrimitiveCulling      = false;
+        layoutNonCoherentTileAttachmentReadQCOM = false;
+        layoutTileShadingRateQCOM[0] = 0;
+        layoutTileShadingRateQCOM[1] = 0;
+        layoutTileShadingRateQCOM[2] = 0;
+        layoutTileShadingRateQCOMNotDefault[0] = false;
+        layoutTileShadingRateQCOMNotDefault[1] = false;
+        layoutTileShadingRateQCOMNotDefault[2] = false;
         primitives                  = TQualifier::layoutNotSet;
         interlockOrdering = EioNone;
     }
@@ -1428,6 +1444,15 @@ struct TShaderQualifiers {
             interlockOrdering = src.interlockOrdering;
         if (src.layoutPrimitiveCulling)
             layoutPrimitiveCulling = src.layoutPrimitiveCulling;
+        if (src.layoutNonCoherentTileAttachmentReadQCOM)
+            layoutNonCoherentTileAttachmentReadQCOM = src.layoutNonCoherentTileAttachmentReadQCOM;
+        for (int i = 0; i < 3; ++i) {
+            if (src.layoutTileShadingRateQCOM[i] > 1)
+                layoutTileShadingRateQCOM[i] = src.layoutTileShadingRateQCOM[i];
+        }
+        for (int i = 0; i < 3; ++i) {
+            layoutTileShadingRateQCOMNotDefault[i] = src.layoutTileShadingRateQCOMNotDefault[i] || layoutTileShadingRateQCOMNotDefault[i];
+        }
     }
 };
 
@@ -1475,6 +1500,8 @@ public:
     uint32_t matrixRows  : 4;
     bool coopmatNV  : 1;
     bool coopmatKHR : 1;
+    bool coopvecNV  : 1;
+    bool tileAttachmentQCOM: 1;
     TArraySizes* arraySizes;
     const TType* userDef;
     TSourceLoc loc;
@@ -1485,6 +1512,11 @@ public:
     bool isCoopmat() const { return coopmatNV || coopmatKHR; }
     bool isCoopmatNV() const { return coopmatNV; }
     bool isCoopmatKHR() const { return coopmatKHR; }
+    bool isCoopvecNV() const { return coopvecNV; }
+    bool isCoopmatOrvec() const { return isCoopmat() || isCoopvecNV(); }
+
+    bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; }
+    bool isTensorViewNV() const { return basicType == EbtTensorViewNV; }
 
     void initType(const TSourceLoc& l)
     {
@@ -1498,6 +1530,8 @@ public:
         typeParameters = nullptr;
         coopmatNV = false;
         coopmatKHR = false;
+        coopvecNV = false;
+        tileAttachmentQCOM = false;
         spirvType = nullptr;
     }
 
@@ -1557,8 +1591,8 @@ public:
     // for "empty" type (no args) or simple scalar/vector/matrix
     explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0,
                    bool isVector = false) :
-                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
+                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            tileAttachmentQCOM(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 assert(vs >= 0);
@@ -1573,8 +1607,8 @@ public:
     // for explicit precision qualifier
     TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0,
           bool isVector = false) :
-                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
+                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            tileAttachmentQCOM(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 assert(vs >= 0);
@@ -1591,8 +1625,8 @@ public:
     // for turning a TPublicType into a TType, using a shallow copy
     explicit TType(const TPublicType& p) :
                             basicType(p.basicType),
-                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters),
+                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(p.coopvecNV),
+                            tileAttachmentQCOM(p.tileAttachmentQCOM), arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters),
                             spirvType(p.spirvType)
                             {
                                 if (basicType == EbtSampler)
@@ -1640,14 +1674,16 @@ public:
                                         assert(dimSize >= 0);
                                         coopmatKHRuse = static_cast<uint32_t>(dimSize) & 0b111;
                                         coopmatKHRUseValid = true;
-                                        p.typeParameters->arraySizes->removeLastSize();
                                     }
                                 }
+                                if (p.isCoopvecNV() && p.typeParameters) {
+                                    basicType = p.typeParameters->basicType;
+                                }
                             }
     // for construction of sampler types
     TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) :
-        basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-        arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
+        basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+        tileAttachmentQCOM(false), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
         sampler(sampler), typeParameters(nullptr), spirvType(nullptr)
     {
         qualifier.clear();
@@ -1689,19 +1725,23 @@ public:
                                         // dereference from vector to scalar
                                         vectorSize = 1;
                                         vector1 = false;
-                                    } else if (isCoopMat()) {
+                                    } else if (isCoopMat() || isCoopVecNV()) {
                                         coopmatNV = false;
                                         coopmatKHR = false;
                                         coopmatKHRuse = 0;
                                         coopmatKHRUseValid = false;
+                                        coopvecNV = false;
+                                        typeParameters = nullptr;
+                                    } else if (isTileAttachmentQCOM()) {
+                                        tileAttachmentQCOM = false;
                                         typeParameters = nullptr;
                                     }
                                 }
                             }
     // for making structures, ...
     TType(TTypeList* userDef, const TString& n) :
-                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
+                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            tileAttachmentQCOM(false), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 sampler.clear();
@@ -1710,8 +1750,8 @@ public:
                             }
     // For interface blocks
     TType(TTypeList* userDef, const TString& n, const TQualifier& q) :
-                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
+                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
+                            tileAttachmentQCOM(false), qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 sampler.clear();
@@ -1720,7 +1760,7 @@ public:
     // for block reference (first parameter must be EbtReference)
     explicit TType(TBasicType t, const TType &p, const TString& n) :
                             basicType(t), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
+                            tileAttachmentQCOM(false), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 assert(t == EbtReference);
@@ -1758,6 +1798,8 @@ public:
         coopmatKHR = copyOf.isCoopMatKHR();
         coopmatKHRuse = copyOf.coopmatKHRuse;
         coopmatKHRUseValid = copyOf.coopmatKHRUseValid;
+        coopvecNV = copyOf.isCoopVecNV();
+        tileAttachmentQCOM = copyOf.tileAttachmentQCOM;
     }
 
     // Make complete copy of the whole type graph rooted at 'copyOf'.
@@ -1841,7 +1883,7 @@ public:
     virtual const TTypeParameters* getTypeParameters() const { return typeParameters; }
     virtual       TTypeParameters* getTypeParameters()       { return typeParameters; }
 
-    virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray(); }
+    virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray() && ! isCoopVecNV(); }
     virtual bool isScalarOrVec1() const { return isScalar() || vector1; }
     virtual bool isScalarOrVector() const { return !isMatrix() && !isStruct() && !isArray(); }
     virtual bool isVector() const { return vectorSize > 1u || vector1; }
@@ -1855,7 +1897,8 @@ public:
     virtual void updateImplicitArraySize(int size) { assert(isArray()); arraySizes->updateImplicitSize(size); }
     virtual void setImplicitlySized(bool isImplicitSized) { arraySizes->setImplicitlySized(isImplicitSized); }
     virtual bool isStruct() const { return basicType == EbtStruct || basicType == EbtBlock; }
-    virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16; }
+    virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16 ||
+                                                   basicType == EbtBFloat16 || basicType == EbtFloatE5M2 || basicType == EbtFloatE4M3; }
     virtual bool isIntegerDomain() const
     {
         switch (basicType) {
@@ -1876,7 +1919,7 @@ public:
     }
     virtual bool isOpaque() const { return basicType == EbtSampler
             || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
-            || basicType == EbtHitObjectNV; }
+            || basicType == EbtHitObjectNV || isTileAttachmentQCOM(); }
     virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; }
 
     virtual bool isAttachmentEXT() const { return basicType == EbtSampler && getSampler().isAttachmentEXT(); }
@@ -1892,10 +1935,16 @@ public:
     bool isCoopMat() const { return coopmatNV || coopmatKHR; }
     bool isCoopMatNV() const { return coopmatNV; }
     bool isCoopMatKHR() const { return coopmatKHR; }
+    bool isCoopVecNV() const { return coopvecNV; }
+    bool isCoopMatOrVec() const { return isCoopMat() || isCoopVecNV(); }
+    bool isTileAttachmentQCOM() const { return tileAttachmentQCOM; }
     bool isReference() const { return getBasicType() == EbtReference; }
     bool isSpirvType() const { return getBasicType() == EbtSpirvType; }
     int getCoopMatKHRuse() const { return static_cast<int>(coopmatKHRuse); }
 
+    bool isTensorLayoutNV() const { return getBasicType() == EbtTensorLayoutNV; }
+    bool isTensorViewNV() const { return getBasicType() == EbtTensorViewNV; }
+
     // return true if this type contains any subtype which satisfies the given predicate.
     template <typename P>
     bool contains(P predicate) const
@@ -1956,6 +2005,9 @@ public:
             case EbtFloat:
             case EbtDouble:
             case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
             case EbtInt8:
             case EbtUint8:
             case EbtInt16:
@@ -1988,6 +2040,10 @@ public:
     {
         return containsBasicType(EbtFloat16);
     }
+    bool containsBFloat16() const
+    {
+        return containsBasicType(EbtBFloat16);
+    }
     bool contains64BitInt() const
     {
         return containsBasicType(EbtInt64) || containsBasicType(EbtUint64);
@@ -2004,6 +2060,10 @@ public:
     {
         return contains([](const TType* t) { return t->coopmatNV || t->coopmatKHR; } );
     }
+    bool containsCoopVec() const
+    {
+        return contains([](const TType* t) { return t->coopvecNV; } );
+    }
     bool containsReference() const
     {
         return containsBasicType(EbtReference);
@@ -2105,6 +2165,9 @@ public:
         case EbtVoid:              return "void";
         case EbtDouble:            return "double";
         case EbtFloat16:           return "float16_t";
+        case EbtBFloat16:          return "bfloat16_t";
+        case EbtFloatE5M2:         return "floate5m2_t";
+        case EbtFloatE4M3:         return "floate4m3_t";
         case EbtInt8:              return "int8_t";
         case EbtUint8:             return "uint8_t";
         case EbtInt16:             return "int16_t";
@@ -2121,6 +2184,9 @@ public:
         case EbtString:            return "string";
         case EbtSpirvType:         return "spirv_type";
         case EbtCoopmat:           return "coopmat";
+        case EbtTensorLayoutNV:    return "tensorLayoutNV";
+        case EbtTensorViewNV:      return "tensorViewNV";
+        case EbtCoopvecNV:         return "coopvecNV";
         default:                   return "unknown type";
         }
     }
@@ -2226,7 +2292,7 @@ public:
                 appendStr(" layoutSecondaryViewportRelativeOffset=");
                 appendInt(qualifier.layoutSecondaryViewportRelativeOffset);
               }
-              
+
               if (qualifier.layoutShaderRecord)
                 appendStr(" shaderRecordNV");
               if (qualifier.layoutFullQuads)
@@ -2289,6 +2355,8 @@ public:
             appendStr(" nonprivate");
           if (qualifier.volatil)
             appendStr(" volatile");
+          if (qualifier.nontemporal)
+            appendStr(" nontemporal");
           if (qualifier.restrict)
             appendStr(" restrict");
           if (qualifier.readonly)
@@ -2431,6 +2499,18 @@ public:
                 appendStr(" ");
                 appendStr("coopmat");
               }
+              if (isTensorLayoutNV()) {
+                appendStr(" ");
+                appendStr("tensorLayoutNV");
+              }
+              if (isTensorViewNV()) {
+                appendStr(" ");
+                appendStr("tensorViewNV");
+              }
+              if (isCoopVecNV()) {
+                appendStr(" ");
+                appendStr("coopvecNV");
+              }
 
               appendStr("<");
               for (int i = 0; i < (int)typeParameters->arraySizes->getNumDims(); ++i) {
@@ -2438,10 +2518,6 @@ public:
                 if (i != (int)typeParameters->arraySizes->getNumDims() - 1)
                   appendStr(", ");
               }
-              if (coopmatKHRUseValid) {
-                  appendStr(", ");
-                  appendInt(coopmatKHRuse);
-              }
               appendStr(">");
             }
             if (getPrecision && qualifier.precision != EpqNone) {
@@ -2516,7 +2592,9 @@ public:
     {
         uint32_t components = 0;
 
-        if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) {
+        if (isCoopVecNV()) {
+            components = typeParameters->arraySizes->getDimSize(0);
+        } else if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) {
             for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++)
                 components += ((*tl).type)->computeNumComponents();
         } else if (matrixCols)
@@ -2720,6 +2798,7 @@ public:
                   vector1 == right.vector1    &&
               isCoopMatNV() == right.isCoopMatNV() &&
               isCoopMatKHR() == right.isCoopMatKHR() &&
+              isCoopVecNV() == right.isCoopVecNV() &&
                sameStructType(right, lpidx, rpidx) &&
                sameReferenceType(right);
     }
@@ -2741,6 +2820,18 @@ public:
         return false;
     }
 
+    // See if a cooperative vector type parameter with unspecified parameters is
+    // an OK function parameter
+    bool coopVecParameterOK(const TType& right) const
+    {
+        if (isCoopVecNV() && right.isCoopVecNV()) {
+            return ((getBasicType() == right.getBasicType()) || (getBasicType() == EbtCoopvecNV) ||
+                    (right.getBasicType() == EbtCoopvecNV)) &&
+                   typeParameters == nullptr && right.typeParameters != nullptr;
+        }
+        return false;
+    }
+
     bool sameCoopMatBaseType(const TType &right) const {
         bool rv = false;
 
@@ -2755,8 +2846,8 @@ public:
             else
                 rv = false;
         } else if (isCoopMatKHR() && right.isCoopMatKHR()) {
-            if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16)
-                rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16 || right.getBasicType() == EbtCoopmat;
+            if (isFloatingDomain())
+                rv = right.isFloatingDomain() || right.getBasicType() == EbtCoopmat;
             else if (getBasicType() == EbtUint || getBasicType() == EbtUint8 || getBasicType() == EbtUint16)
                 rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8 || right.getBasicType() == EbtUint16 || right.getBasicType() == EbtCoopmat;
             else if (getBasicType() == EbtInt || getBasicType() == EbtInt8 || getBasicType() == EbtInt16)
@@ -2767,27 +2858,63 @@ public:
         return rv;
     }
 
+    bool tensorParameterOK(const TType& right) const
+    {
+        if (isTensorLayoutNV()) {
+            return right.isTensorLayoutNV() && right.typeParameters == nullptr && typeParameters != nullptr;
+        }
+        if (isTensorViewNV()) {
+            return right.isTensorViewNV() && right.typeParameters == nullptr && typeParameters != nullptr;
+        }
+        return false;
+    }
+
+    bool sameCoopVecBaseType(const TType &right) const {
+        bool rv = false;
+
+        if (isCoopVecNV() && right.isCoopVecNV()) {
+            if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16)
+                rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16 || right.getBasicType() == EbtCoopvecNV;
+            else if (getBasicType() == EbtUint || getBasicType() == EbtUint8 || getBasicType() == EbtUint16)
+                rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8 || right.getBasicType() == EbtUint16 || right.getBasicType() == EbtCoopvecNV;
+            else if (getBasicType() == EbtInt || getBasicType() == EbtInt8 || getBasicType() == EbtInt16)
+                rv = right.getBasicType() == EbtInt || right.getBasicType() == EbtInt8 || right.getBasicType() == EbtInt16 || right.getBasicType() == EbtCoopvecNV;
+            else
+                rv = false;
+        }
+        return rv;
+    }
+
     bool sameCoopMatUse(const TType &right) const {
         return coopmatKHRuse == right.coopmatKHRuse;
     }
 
-    bool sameCoopMatShapeAndUse(const TType &right) const
+    bool sameCoopMatShape(const TType &right) const
     {
         if (!isCoopMat() || !right.isCoopMat() || isCoopMatKHR() != right.isCoopMatKHR())
             return false;
 
-        if (coopmatKHRuse != right.coopmatKHRuse)
-            return false;
-
         // Skip bit width type parameter (first array size) for coopmatNV
         int firstArrayDimToCompare = isCoopMatNV() ? 1 : 0;
-        for (int i = firstArrayDimToCompare; i < typeParameters->arraySizes->getNumDims(); ++i) {
+        int lastArrayDimToCompare = typeParameters->arraySizes->getNumDims() - (isCoopMatKHR() ? 1 : 0);
+        for (int i = firstArrayDimToCompare; i < lastArrayDimToCompare; ++i) {
             if (typeParameters->arraySizes->getDimSize(i) != right.typeParameters->arraySizes->getDimSize(i))
                 return false;
         }
         return true;
     }
 
+    bool sameCoopMatShapeAndUse(const TType &right) const
+    {
+        if (!sameCoopMatShape(right))
+            return false;
+
+        if (coopmatKHRuse != right.coopmatKHRuse)
+            return false;
+
+        return true;
+    }
+
     // See if two types match in all ways (just the actual type, not qualification)
     bool operator==(const TType& right) const
     {
@@ -2842,7 +2969,9 @@ protected:
             typeParameters = new TTypeParameters;
             typeParameters->arraySizes = new TArraySizes;
             *typeParameters->arraySizes = *copyOf.typeParameters->arraySizes;
-            *typeParameters->spirvType = *copyOf.typeParameters->spirvType;
+            if (copyOf.typeParameters->spirvType) {
+                *typeParameters->spirvType = *copyOf.typeParameters->spirvType;
+            }
             typeParameters->basicType = copyOf.basicType;
         }
 
@@ -2885,6 +3014,8 @@ protected:
     bool coopmatKHR      : 1;
     uint32_t coopmatKHRuse    : 3;  // Accepts one of three values: 0, 1, 2 (gl_MatrixUseA, gl_MatrixUseB, gl_MatrixUseAccumulator)
     bool coopmatKHRUseValid   : 1;  // True if coopmatKHRuse has been set
+    bool coopvecNV       : 1;
+    bool tileAttachmentQCOM : 1;
     TQualifier qualifier;
 
     TArraySizes* arraySizes;    // nullptr unless an array; can be shared across types

+ 95 - 187
src/libraries/glslang/glslang/Include/intermediate.h

@@ -87,189 +87,9 @@ enum TOperator {
 
     EOpDeclare,        // Used by debugging to force declaration of variable in correct scope
 
-    // (u)int* -> bool
-    EOpConvInt8ToBool,
-    EOpConvUint8ToBool,
-    EOpConvInt16ToBool,
-    EOpConvUint16ToBool,
-    EOpConvIntToBool,
-    EOpConvUintToBool,
-    EOpConvInt64ToBool,
-    EOpConvUint64ToBool,
-
-    // float* -> bool
-    EOpConvFloat16ToBool,
-    EOpConvFloatToBool,
-    EOpConvDoubleToBool,
-
-    // bool -> (u)int*
-    EOpConvBoolToInt8,
-    EOpConvBoolToUint8,
-    EOpConvBoolToInt16,
-    EOpConvBoolToUint16,
-    EOpConvBoolToInt,
-    EOpConvBoolToUint,
-    EOpConvBoolToInt64,
-    EOpConvBoolToUint64,
-
-    // bool -> float*
-    EOpConvBoolToFloat16,
-    EOpConvBoolToFloat,
-    EOpConvBoolToDouble,
-
-    // int8_t -> (u)int*
-    EOpConvInt8ToInt16,
-    EOpConvInt8ToInt,
-    EOpConvInt8ToInt64,
-    EOpConvInt8ToUint8,
-    EOpConvInt8ToUint16,
-    EOpConvInt8ToUint,
-    EOpConvInt8ToUint64,
-
-    // uint8_t -> (u)int*
-    EOpConvUint8ToInt8,
-    EOpConvUint8ToInt16,
-    EOpConvUint8ToInt,
-    EOpConvUint8ToInt64,
-    EOpConvUint8ToUint16,
-    EOpConvUint8ToUint,
-    EOpConvUint8ToUint64,
-
-    // int8_t -> float*
-    EOpConvInt8ToFloat16,
-    EOpConvInt8ToFloat,
-    EOpConvInt8ToDouble,
-
-    // uint8_t -> float*
-    EOpConvUint8ToFloat16,
-    EOpConvUint8ToFloat,
-    EOpConvUint8ToDouble,
-
-    // int16_t -> (u)int*
-    EOpConvInt16ToInt8,
-    EOpConvInt16ToInt,
-    EOpConvInt16ToInt64,
-    EOpConvInt16ToUint8,
-    EOpConvInt16ToUint16,
-    EOpConvInt16ToUint,
-    EOpConvInt16ToUint64,
-
-    // uint16_t -> (u)int*
-    EOpConvUint16ToInt8,
-    EOpConvUint16ToInt16,
-    EOpConvUint16ToInt,
-    EOpConvUint16ToInt64,
-    EOpConvUint16ToUint8,
-    EOpConvUint16ToUint,
-    EOpConvUint16ToUint64,
-
-    // int16_t -> float*
-    EOpConvInt16ToFloat16,
-    EOpConvInt16ToFloat,
-    EOpConvInt16ToDouble,
-
-    // uint16_t -> float*
-    EOpConvUint16ToFloat16,
-    EOpConvUint16ToFloat,
-    EOpConvUint16ToDouble,
-
-    // int32_t -> (u)int*
-    EOpConvIntToInt8,
-    EOpConvIntToInt16,
-    EOpConvIntToInt64,
-    EOpConvIntToUint8,
-    EOpConvIntToUint16,
-    EOpConvIntToUint,
-    EOpConvIntToUint64,
-
-    // uint32_t -> (u)int*
-    EOpConvUintToInt8,
-    EOpConvUintToInt16,
-    EOpConvUintToInt,
-    EOpConvUintToInt64,
-    EOpConvUintToUint8,
-    EOpConvUintToUint16,
-    EOpConvUintToUint64,
-
-    // int32_t -> float*
-    EOpConvIntToFloat16,
-    EOpConvIntToFloat,
-    EOpConvIntToDouble,
-
-    // uint32_t -> float*
-    EOpConvUintToFloat16,
-    EOpConvUintToFloat,
-    EOpConvUintToDouble,
-
-    // int64_t -> (u)int*
-    EOpConvInt64ToInt8,
-    EOpConvInt64ToInt16,
-    EOpConvInt64ToInt,
-    EOpConvInt64ToUint8,
-    EOpConvInt64ToUint16,
-    EOpConvInt64ToUint,
-    EOpConvInt64ToUint64,
-
-    // uint64_t -> (u)int*
-    EOpConvUint64ToInt8,
-    EOpConvUint64ToInt16,
-    EOpConvUint64ToInt,
-    EOpConvUint64ToInt64,
-    EOpConvUint64ToUint8,
-    EOpConvUint64ToUint16,
-    EOpConvUint64ToUint,
-
-    // int64_t -> float*
-    EOpConvInt64ToFloat16,
-    EOpConvInt64ToFloat,
-    EOpConvInt64ToDouble,
-
-    // uint64_t -> float*
-    EOpConvUint64ToFloat16,
-    EOpConvUint64ToFloat,
-    EOpConvUint64ToDouble,
-
-    // float16_t -> (u)int*
-    EOpConvFloat16ToInt8,
-    EOpConvFloat16ToInt16,
-    EOpConvFloat16ToInt,
-    EOpConvFloat16ToInt64,
-    EOpConvFloat16ToUint8,
-    EOpConvFloat16ToUint16,
-    EOpConvFloat16ToUint,
-    EOpConvFloat16ToUint64,
-
-    // float16_t -> float*
-    EOpConvFloat16ToFloat,
-    EOpConvFloat16ToDouble,
-
-    // float -> (u)int*
-    EOpConvFloatToInt8,
-    EOpConvFloatToInt16,
-    EOpConvFloatToInt,
-    EOpConvFloatToInt64,
-    EOpConvFloatToUint8,
-    EOpConvFloatToUint16,
-    EOpConvFloatToUint,
-    EOpConvFloatToUint64,
-
-    // float -> float*
-    EOpConvFloatToFloat16,
-    EOpConvFloatToDouble,
-
-    // float64 _t-> (u)int*
-    EOpConvDoubleToInt8,
-    EOpConvDoubleToInt16,
-    EOpConvDoubleToInt,
-    EOpConvDoubleToInt64,
-    EOpConvDoubleToUint8,
-    EOpConvDoubleToUint16,
-    EOpConvDoubleToUint,
-    EOpConvDoubleToUint64,
-
-    // float64_t -> float*
-    EOpConvDoubleToFloat16,
-    EOpConvDoubleToFloat,
+    // Operator used to represent all conversions between int, float, and bool.
+    // The specific types are inferred from TBasicType.
+    EOpConvNumeric,
 
     // uint64_t <-> pointer
     EOpConvUint64ToPtr,
@@ -567,6 +387,11 @@ enum TOperator {
     EOpSubgroupPartitionedExclusiveXor,
 
     EOpSubgroupGuardStop,
+    
+    // Integer dot product
+    EOpDotPackedEXT,
+    EOpDotAccSatEXT,
+    EOpDotPackedAccSatEXT,
 
     EOpMinInvocations,
     EOpMaxInvocations,
@@ -628,7 +453,31 @@ enum TOperator {
     EOpCooperativeMatrixMulAdd,
     EOpCooperativeMatrixLoadNV,
     EOpCooperativeMatrixStoreNV,
+    EOpCooperativeMatrixLoadTensorNV,
+    EOpCooperativeMatrixStoreTensorNV,
     EOpCooperativeMatrixMulAddNV,
+    EOpCooperativeMatrixReduceNV,
+    EOpCooperativeMatrixPerElementOpNV,
+    EOpCooperativeMatrixTransposeNV,
+
+    EOpCreateTensorLayoutNV,
+    EOpTensorLayoutSetBlockSizeNV,
+    EOpTensorLayoutSetDimensionNV,
+    EOpTensorLayoutSetStrideNV,
+    EOpTensorLayoutSliceNV,
+    EOpTensorLayoutSetClampValueNV,
+
+    EOpCreateTensorViewNV,
+    EOpTensorViewSetDimensionNV,
+    EOpTensorViewSetStrideNV,
+    EOpTensorViewSetClipNV,
+
+    EOpCooperativeVectorMatMulNV,
+    EOpCooperativeVectorMatMulAddNV,
+    EOpCooperativeVectorLoadNV,
+    EOpCooperativeVectorStoreNV,
+    EOpCooperativeVectorOuterProductAccumulateNV,
+    EOpCooperativeVectorReduceSumAccumulateNV,
 
     EOpBeginInvocationInterlock, // Fragment only
     EOpEndInvocationInterlock, // Fragment only
@@ -762,13 +611,27 @@ enum TOperator {
     EOpConstructF16Mat4x2,
     EOpConstructF16Mat4x3,
     EOpConstructF16Mat4x4,
+    EOpConstructBFloat16,
+    EOpConstructBF16Vec2,
+    EOpConstructBF16Vec3,
+    EOpConstructBF16Vec4,
+    EOpConstructFloatE5M2,
+    EOpConstructFloatE5M2Vec2,
+    EOpConstructFloatE5M2Vec3,
+    EOpConstructFloatE5M2Vec4,
+    EOpConstructFloatE4M3,
+    EOpConstructFloatE4M3Vec2,
+    EOpConstructFloatE4M3Vec3,
+    EOpConstructFloatE4M3Vec4,
     EOpConstructStruct,
     EOpConstructTextureSampler,
     EOpConstructNonuniform,     // expected to be transformed away, not present in final AST
     EOpConstructReference,
     EOpConstructCooperativeMatrixNV,
     EOpConstructCooperativeMatrixKHR,
+    EOpConstructCooperativeVectorNV,
     EOpConstructAccStruct,
+    EOpConstructSaturated,
     EOpConstructGuardEnd,
 
     //
@@ -1117,8 +980,31 @@ enum TOperator {
     EOpImageBlockMatchWindowSADQCOM,
     EOpImageBlockMatchGatherSSDQCOM,
     EOpImageBlockMatchGatherSADQCOM,
+
+    // GL_NV_cluster_acceleration_structure
+    EOpRayQueryGetIntersectionClusterIdNV,
+    EOpHitObjectGetClusterIdNV,
+
+    // GL_NV_linear_swept_spheres
+    EOpRayQueryGetIntersectionSpherePositionNV,
+    EOpRayQueryGetIntersectionSphereRadiusNV,
+    EOpRayQueryGetIntersectionLSSHitValueNV,
+    EOpRayQueryGetIntersectionLSSPositionsNV,
+    EOpRayQueryGetIntersectionLSSRadiiNV,
+    EOpRayQueryIsSphereHitNV,
+    EOpRayQueryIsLSSHitNV,
+    EOpHitObjectGetSpherePositionNV,
+    EOpHitObjectGetSphereRadiusNV,
+    EOpHitObjectGetLSSPositionsNV,
+    EOpHitObjectGetLSSRadiiNV,
+    EOpHitObjectIsSphereHitNV,
+    EOpHitObjectIsLSSHitNV,
 };
 
+inline bool IsOpNumericConv(const TOperator op) {
+    return op == EOpConvNumeric;
+}
+
 enum TLinkType {
     ELinkNone,
     ELinkExport,
@@ -1356,11 +1242,19 @@ public:
     // if symbol is initialized as symbol(sym), the memory comes from the pool allocator of sym. If sym comes from
     // per process threadPoolAllocator, then it causes increased memory usage per compile
     // it is essential to use "symbol = sym" to assign to symbol
-    TIntermSymbol(long long i, const TString& n, const TType& t)
-        : TIntermTyped(t), id(i), flattenSubset(-1), constSubtree(nullptr) { name = n; }
+    TIntermSymbol(long long i, const TString& n, EShLanguage s, const TType& t, const TString* mn = nullptr)
+        : TIntermTyped(t), id(i), flattenSubset(-1), stage(s), constSubtree(nullptr) { 
+        name = n;
+        if (mn) {
+            mangledName = *mn;
+        } else {
+            mangledName = n;
+        }
+    }
     virtual long long getId() const { return id; }
     virtual void changeId(long long i) { id = i; }
     virtual const TString& getName() const { return name; }
+    virtual const TString& getMangledName() const { return mangledName; }
     virtual void traverse(TIntermTraverser*);
     virtual       TIntermSymbol* getAsSymbolNode()       { return this; }
     virtual const TIntermSymbol* getAsSymbolNode() const { return this; }
@@ -1376,11 +1270,14 @@ public:
     // This is meant for cases where a node has already been constructed, and
     // later on, it becomes necessary to switch to a different symbol.
     virtual void switchId(long long newId) { id = newId; }
+    EShLanguage getStage() const { return stage; }
 
 protected:
     long long id;                // the unique id of the symbol this node represents
     int flattenSubset;           // how deeply the flattened object rooted at id has been dereferenced
     TString name;                // the name of the symbol this node represents
+    EShLanguage stage;
+    TString mangledName;         // mangled function name, or a copy of name if not a function
     TConstUnionArray constArray; // if the symbol is a front-end compile-time constant, this is its value
     TIntermTyped* constSubtree;
 };
@@ -1694,8 +1591,12 @@ typedef TVector<TStorageQualifier> TQualifierList;
 //
 class TIntermAggregate : public TIntermOperator {
 public:
-    TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(nullptr) { }
-    TIntermAggregate(TOperator o) : TIntermOperator(o), pragmaTable(nullptr) { }
+    TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(nullptr) { 
+        endLoc.init();
+    }
+    TIntermAggregate(TOperator o) : TIntermOperator(o), pragmaTable(nullptr) {
+        endLoc.init();
+    }
     ~TIntermAggregate() { delete pragmaTable; }
     virtual       TIntermAggregate* getAsAggregate()       { return this; }
     virtual const TIntermAggregate* getAsAggregate() const { return this; }
@@ -1719,6 +1620,9 @@ public:
     void setSpirvInstruction(const TSpirvInstruction& inst) { spirvInst = inst; }
     const TSpirvInstruction& getSpirvInstruction() const { return spirvInst; }
 
+    void setEndLoc(TSourceLoc loc) { endLoc = loc; }
+    TSourceLoc getEndLoc() const { return endLoc; }
+
     void setLinkType(TLinkType l) { linkType = l; }
     TLinkType getLinkType() const { return linkType; }
 protected:
@@ -1733,6 +1637,10 @@ protected:
     TPragmaTable* pragmaTable;
     TSpirvInstruction spirvInst;
     TLinkType linkType = ELinkNone;
+
+    // Marking the end source location of the aggregate.
+    // This is currently only set for a compound statement or a function body, pointing to '}'.
+    TSourceLoc endLoc;
 };
 
 //

+ 54 - 0
src/libraries/glslang/glslang/Include/visibility.h

@@ -0,0 +1,54 @@
+//
+// Copyright (C) 2023 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.
+//
+#ifdef GLSLANG_IS_SHARED_LIBRARY
+    #ifdef _WIN32
+        #ifdef GLSLANG_EXPORTING
+            #define GLSLANG_EXPORT __declspec(dllexport)
+        #else
+            #define GLSLANG_EXPORT __declspec(dllimport)
+        #endif
+    #elif __GNUC__ >= 4
+        #define GLSLANG_EXPORT __attribute__((visibility("default")))
+    #endif
+#endif // GLSLANG_IS_SHARED_LIBRARY
+
+#ifndef GLSLANG_EXPORT
+#define GLSLANG_EXPORT
+#endif
+
+// Symbols marked with this macro are only meant for public use by the test suite
+// and do not appear in publicly installed headers. They are not considered to be
+// part of the glslang library ABI.
+#define GLSLANG_EXPORT_FOR_TESTS GLSLANG_EXPORT

+ 184 - 271
src/libraries/glslang/glslang/MachineIndependent/Constant.cpp

@@ -151,6 +151,9 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TIntermTyped* right
             case EbtDouble:
             case EbtFloat:
             case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
                 if (rightUnionArray[i].getDConst() != 0.0)
                     newConstArray[i].setDConst(leftUnionArray[i].getDConst() / rightUnionArray[i].getDConst());
                 else if (leftUnionArray[i].getDConst() > 0.0)
@@ -490,11 +493,180 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType)
 
     // Process component-wise operations
     for (int i = 0; i < objectSize; i++) {
+        // First read the value and convert to i64/u64/f64/bool, then convert
+        // to the destination type (still 64b), then convert down to the
+        // destination size.
+        if (IsOpNumericConv(op)) {
+            enum ConvType { CONV_FLOAT, CONV_INT, CONV_UINT, CONV_BOOL };
+            ConvType srcType = CONV_UINT, dstType = CONV_UINT;
+            double valf = 0.0;
+            uint64_t valu = 0;
+            int64_t vali = 0;
+            bool valb = false;
+            switch (getType().getBasicType()) {
+            case EbtDouble:
+            case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+            case EbtFloat:
+                valf = unionArray[i].getDConst();
+                srcType = CONV_FLOAT;
+                break;
+            case EbtInt8:
+                vali = unionArray[i].getI8Const();
+                srcType = CONV_INT;
+                break;
+            case EbtInt16:
+                vali = unionArray[i].getI16Const();
+                srcType = CONV_INT;
+                break;
+            case EbtInt:
+                vali = unionArray[i].getIConst();
+                srcType = CONV_INT;
+                break;
+            case EbtInt64:
+                vali = unionArray[i].getI64Const();
+                srcType = CONV_INT;
+                break;
+            case EbtUint8:
+                valu = unionArray[i].getU8Const();
+                srcType = CONV_UINT;
+                break;
+            case EbtUint16:
+                valu = unionArray[i].getU16Const();
+                srcType = CONV_UINT;
+                break;
+            case EbtUint:
+                valu = unionArray[i].getUConst();
+                srcType = CONV_UINT;
+                break;
+            case EbtUint64:
+                valu = unionArray[i].getU64Const();
+                srcType = CONV_UINT;
+                break;
+            case EbtBool:
+                valb = unionArray[i].getBConst();
+                srcType = CONV_BOOL;
+                break;
+            default:
+                assert(0);
+                break;
+            }
+
+            switch (returnType.getBasicType()) {
+            case EbtDouble:
+            case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+            case EbtFloat:
+                dstType = CONV_FLOAT;
+                break;
+            case EbtInt8:
+            case EbtInt16:
+            case EbtInt:
+            case EbtInt64:
+                dstType = CONV_INT;
+                break;
+            case EbtUint8:
+            case EbtUint16:
+            case EbtUint:
+            case EbtUint64:
+                dstType = CONV_UINT;
+                break;
+            case EbtBool:
+                dstType = CONV_BOOL;
+                break;
+            default:
+                assert(0);
+                break;
+            }
+            if (dstType == CONV_BOOL) {
+                switch (srcType) {
+                case CONV_FLOAT:
+                    valb = (valf != 0.0); break;
+                case CONV_INT:
+                    valb = (vali != 0.0); break;
+                case CONV_UINT:
+                    valb = (valu != 0.0); break;
+                default:
+                    break;
+                }
+            } else if (dstType == CONV_FLOAT) {
+                switch (srcType) {
+                case CONV_BOOL:
+                    valf = (double)valb; break;
+                case CONV_INT:
+                    valf = (double)vali; break;
+                case CONV_UINT:
+                    valf = (double)valu; break;
+                default:
+                    break;
+                }
+            } else if (dstType == CONV_INT) {
+                switch (srcType) {
+                case CONV_BOOL:
+                    vali = (int64_t)valb; break;
+                case CONV_FLOAT:
+                    vali = (int64_t)valf; break;
+                case CONV_UINT:
+                    vali = (int64_t)valu; break;
+                default:
+                    break;
+                }
+            } else if (dstType == CONV_UINT) {
+                switch (srcType) {
+                case CONV_BOOL:
+                    valu = (uint64_t)valb; break;
+                case CONV_FLOAT:
+                    valu = (uint64_t)valf; break;
+                case CONV_INT:
+                    valu = (uint64_t)vali; break;
+                default:
+                    break;
+                }
+            }
+            switch (returnType.getBasicType()) {
+            case EbtDouble:
+            case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+            case EbtFloat:
+                newConstArray[i].setDConst(valf); break;
+            case EbtInt8:
+                newConstArray[i].setI8Const(static_cast<int8_t>(vali)); break;
+            case EbtInt16:
+                newConstArray[i].setI16Const(static_cast<int16_t>(vali)); break;
+            case EbtInt:
+                newConstArray[i].setIConst(static_cast<int32_t>(vali)); break;
+            case EbtInt64:
+                newConstArray[i].setI64Const(vali); break;
+            case EbtUint8:
+                newConstArray[i].setU8Const(static_cast<uint8_t>(valu)); break;
+            case EbtUint16:
+                newConstArray[i].setU16Const(static_cast<uint16_t>(valu)); break;
+            case EbtUint:
+                newConstArray[i].setUConst(static_cast<uint32_t>(valu)); break;
+            case EbtUint64:
+                newConstArray[i].setU64Const(valu); break;
+            case EbtBool:
+                newConstArray[i].setBConst(valb); break;
+            default:
+                assert(0);
+                break;
+            }
+            continue;
+        }
         switch (op) {
         case EOpNegative:
             switch (getType().getBasicType()) {
             case EbtDouble:
             case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
             case EbtFloat: newConstArray[i].setDConst(-unionArray[i].getDConst()); break;
             // Note: avoid UBSAN error regarding negating 0x80000000
             case EbtInt:   newConstArray[i].setIConst(
@@ -641,277 +813,6 @@ TIntermTyped* TIntermConstantUnion::fold(TOperator op, const TType& returnType)
             break;
         }
 
-        case EOpConvIntToBool:
-            newConstArray[i].setBConst(unionArray[i].getIConst() != 0); break;
-        case EOpConvUintToBool:
-            newConstArray[i].setBConst(unionArray[i].getUConst() != 0); break;
-        case EOpConvBoolToInt:
-            newConstArray[i].setIConst(unionArray[i].getBConst()); break;
-        case EOpConvBoolToUint:
-            newConstArray[i].setUConst(unionArray[i].getBConst()); break;
-        case EOpConvIntToUint:
-            newConstArray[i].setUConst(unionArray[i].getIConst()); break;
-        case EOpConvUintToInt:
-            newConstArray[i].setIConst(unionArray[i].getUConst()); break;
-
-        case EOpConvFloatToBool:
-        case EOpConvDoubleToBool:
-            newConstArray[i].setBConst(unionArray[i].getDConst() != 0); break;
-
-        case EOpConvBoolToFloat:
-        case EOpConvBoolToDouble:
-            newConstArray[i].setDConst(unionArray[i].getBConst()); break;
-
-        case EOpConvIntToFloat:
-        case EOpConvIntToDouble:
-            newConstArray[i].setDConst(unionArray[i].getIConst()); break;
-
-        case EOpConvUintToFloat:
-        case EOpConvUintToDouble:
-            newConstArray[i].setDConst(unionArray[i].getUConst()); break;
-
-        case EOpConvDoubleToFloat:
-        case EOpConvFloatToDouble:
-            newConstArray[i].setDConst(unionArray[i].getDConst()); break;
-
-        case EOpConvFloatToUint:
-        case EOpConvDoubleToUint:
-            newConstArray[i].setUConst(static_cast<unsigned int>(unionArray[i].getDConst())); break;
-
-        case EOpConvFloatToInt:
-        case EOpConvDoubleToInt:
-            newConstArray[i].setIConst(static_cast<int>(unionArray[i].getDConst())); break;
-
-        case EOpConvInt8ToBool:
-            newConstArray[i].setBConst(unionArray[i].getI8Const() != 0); break;
-        case EOpConvUint8ToBool:
-            newConstArray[i].setBConst(unionArray[i].getU8Const() != 0); break;
-        case EOpConvInt16ToBool:
-            newConstArray[i].setBConst(unionArray[i].getI16Const() != 0); break;
-        case EOpConvUint16ToBool:
-            newConstArray[i].setBConst(unionArray[i].getU16Const() != 0); break;
-        case EOpConvInt64ToBool:
-            newConstArray[i].setBConst(unionArray[i].getI64Const() != 0); break;
-        case EOpConvUint64ToBool:
-            newConstArray[i].setBConst(unionArray[i].getU64Const() != 0); break;
-        case EOpConvFloat16ToBool:
-            newConstArray[i].setBConst(unionArray[i].getDConst() != 0); break;
-
-        case EOpConvBoolToInt8:
-            newConstArray[i].setI8Const(unionArray[i].getBConst()); break;
-        case EOpConvBoolToUint8:
-            newConstArray[i].setU8Const(unionArray[i].getBConst()); break;
-        case EOpConvBoolToInt16:
-            newConstArray[i].setI16Const(unionArray[i].getBConst()); break;
-        case EOpConvBoolToUint16:
-            newConstArray[i].setU16Const(unionArray[i].getBConst()); break;
-        case EOpConvBoolToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getBConst()); break;
-        case EOpConvBoolToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getBConst()); break;
-        case EOpConvBoolToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getBConst()); break;
-
-        case EOpConvInt8ToInt16:
-            newConstArray[i].setI16Const(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToInt:
-            newConstArray[i].setIConst(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToUint8:
-            newConstArray[i].setU8Const(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToUint16:
-            newConstArray[i].setU16Const(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToUint:
-            newConstArray[i].setUConst(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getI8Const()); break;
-        case EOpConvUint8ToInt8:
-            newConstArray[i].setI8Const(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToInt16:
-            newConstArray[i].setI16Const(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToInt:
-            newConstArray[i].setIConst(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToUint16:
-            newConstArray[i].setU16Const(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToUint:
-            newConstArray[i].setUConst(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getU8Const()); break;
-        case EOpConvInt8ToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToFloat:
-            newConstArray[i].setDConst(unionArray[i].getI8Const()); break;
-        case EOpConvInt8ToDouble:
-            newConstArray[i].setDConst(unionArray[i].getI8Const()); break;
-        case EOpConvUint8ToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToFloat:
-            newConstArray[i].setDConst(unionArray[i].getU8Const()); break;
-        case EOpConvUint8ToDouble:
-            newConstArray[i].setDConst(unionArray[i].getU8Const()); break;
-
-        case EOpConvInt16ToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getI16Const())); break;
-        case EOpConvInt16ToInt:
-            newConstArray[i].setIConst(unionArray[i].getI16Const()); break;
-        case EOpConvInt16ToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getI16Const()); break;
-        case EOpConvInt16ToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getI16Const())); break;
-        case EOpConvInt16ToUint16:
-            newConstArray[i].setU16Const(unionArray[i].getI16Const()); break;
-        case EOpConvInt16ToUint:
-            newConstArray[i].setUConst(unionArray[i].getI16Const()); break;
-        case EOpConvInt16ToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getI16Const()); break;
-        case EOpConvUint16ToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getU16Const())); break;
-        case EOpConvUint16ToInt16:
-            newConstArray[i].setI16Const(unionArray[i].getU16Const()); break;
-        case EOpConvUint16ToInt:
-            newConstArray[i].setIConst(unionArray[i].getU16Const()); break;
-        case EOpConvUint16ToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getU16Const()); break;
-        case EOpConvUint16ToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getU16Const())); break;
-
-        case EOpConvUint16ToUint:
-            newConstArray[i].setUConst(unionArray[i].getU16Const()); break;
-        case EOpConvUint16ToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getU16Const()); break;
-        case EOpConvInt16ToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getI16Const()); break;
-        case EOpConvInt16ToFloat:
-            newConstArray[i].setDConst(unionArray[i].getI16Const()); break;
-        case EOpConvInt16ToDouble:
-            newConstArray[i].setDConst(unionArray[i].getI16Const()); break;
-        case EOpConvUint16ToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getU16Const()); break;
-        case EOpConvUint16ToFloat:
-            newConstArray[i].setDConst(unionArray[i].getU16Const()); break;
-        case EOpConvUint16ToDouble:
-            newConstArray[i].setDConst(unionArray[i].getU16Const()); break;
-
-        case EOpConvIntToInt8:
-            newConstArray[i].setI8Const((signed char)unionArray[i].getIConst()); break;
-        case EOpConvIntToInt16:
-            newConstArray[i].setI16Const((signed short)unionArray[i].getIConst()); break;
-        case EOpConvIntToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getIConst()); break;
-        case EOpConvIntToUint8:
-            newConstArray[i].setU8Const((unsigned char)unionArray[i].getIConst()); break;
-        case EOpConvIntToUint16:
-            newConstArray[i].setU16Const((unsigned char)unionArray[i].getIConst()); break;
-        case EOpConvIntToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getIConst()); break;
-
-        case EOpConvUintToInt8:
-            newConstArray[i].setI8Const((signed char)unionArray[i].getUConst()); break;
-        case EOpConvUintToInt16:
-            newConstArray[i].setI16Const((signed short)unionArray[i].getUConst()); break;
-        case EOpConvUintToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getUConst()); break;
-        case EOpConvUintToUint8:
-            newConstArray[i].setU8Const((unsigned char)unionArray[i].getUConst()); break;
-        case EOpConvUintToUint16:
-            newConstArray[i].setU16Const((unsigned short)unionArray[i].getUConst()); break;
-        case EOpConvUintToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getUConst()); break;
-        case EOpConvIntToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getIConst()); break;
-        case EOpConvUintToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getUConst()); break;
-        case EOpConvInt64ToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToInt16:
-            newConstArray[i].setI16Const(static_cast<signed short>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToInt:
-            newConstArray[i].setIConst(static_cast<int>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToUint16:
-            newConstArray[i].setU16Const(static_cast<unsigned short>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToUint:
-            newConstArray[i].setUConst(static_cast<unsigned int>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToUint64:
-            newConstArray[i].setU64Const(unionArray[i].getI64Const()); break;
-        case EOpConvUint64ToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToInt16:
-            newConstArray[i].setI16Const(static_cast<signed short>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToInt:
-            newConstArray[i].setIConst(static_cast<int>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToInt64:
-            newConstArray[i].setI64Const(unionArray[i].getU64Const()); break;
-        case EOpConvUint64ToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToUint16:
-            newConstArray[i].setU16Const(static_cast<unsigned short>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToUint:
-            newConstArray[i].setUConst(static_cast<unsigned int>(unionArray[i].getU64Const())); break;
-        case EOpConvInt64ToFloat16:
-            newConstArray[i].setDConst(static_cast<double>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToFloat:
-            newConstArray[i].setDConst(static_cast<double>(unionArray[i].getI64Const())); break;
-        case EOpConvInt64ToDouble:
-            newConstArray[i].setDConst(static_cast<double>(unionArray[i].getI64Const())); break;
-        case EOpConvUint64ToFloat16:
-            newConstArray[i].setDConst(static_cast<double>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToFloat:
-            newConstArray[i].setDConst(static_cast<double>(unionArray[i].getU64Const())); break;
-        case EOpConvUint64ToDouble:
-            newConstArray[i].setDConst(static_cast<double>(unionArray[i].getU64Const())); break;
-        case EOpConvFloat16ToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToInt16:
-            newConstArray[i].setI16Const(static_cast<signed short>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToInt:
-            newConstArray[i].setIConst(static_cast<int>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToInt64:
-            newConstArray[i].setI64Const(static_cast<long long>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToUint16:
-            newConstArray[i].setU16Const(static_cast<unsigned short>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToUint:
-            newConstArray[i].setUConst(static_cast<unsigned int>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToUint64:
-            newConstArray[i].setU64Const(static_cast<unsigned long long>(unionArray[i].getDConst())); break;
-        case EOpConvFloat16ToFloat:
-            newConstArray[i].setDConst(unionArray[i].getDConst()); break;
-        case EOpConvFloat16ToDouble:
-            newConstArray[i].setDConst(unionArray[i].getDConst()); break;
-        case EOpConvFloatToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getDConst())); break;
-        case EOpConvFloatToInt16:
-            newConstArray[i].setI16Const(static_cast<signed short>(unionArray[i].getDConst())); break;
-        case EOpConvFloatToInt64:
-            newConstArray[i].setI64Const(static_cast<long long>(unionArray[i].getDConst())); break;
-        case EOpConvFloatToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getDConst())); break;
-        case EOpConvFloatToUint16:
-            newConstArray[i].setU16Const(static_cast<unsigned short>(unionArray[i].getDConst())); break;
-        case EOpConvFloatToUint64:
-            newConstArray[i].setU64Const(static_cast<unsigned long long>(unionArray[i].getDConst())); break;
-        case EOpConvFloatToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getDConst()); break;
-        case EOpConvDoubleToInt8:
-            newConstArray[i].setI8Const(static_cast<signed char>(unionArray[i].getDConst())); break;
-        case EOpConvDoubleToInt16:
-            newConstArray[i].setI16Const(static_cast<signed short>(unionArray[i].getDConst())); break;
-        case EOpConvDoubleToInt64:
-            newConstArray[i].setI64Const(static_cast<long long>(unionArray[i].getDConst())); break;
-        case EOpConvDoubleToUint8:
-            newConstArray[i].setU8Const(static_cast<unsigned char>(unionArray[i].getDConst())); break;
-        case EOpConvDoubleToUint16:
-            newConstArray[i].setU16Const(static_cast<unsigned short>(unionArray[i].getDConst())); break;
-        case EOpConvDoubleToUint64:
-            newConstArray[i].setU64Const(static_cast<unsigned long long>(unionArray[i].getDConst())); break;
-        case EOpConvDoubleToFloat16:
-            newConstArray[i].setDConst(unionArray[i].getDConst()); break;
         case EOpConvPtrToUint64:
         case EOpConvUint64ToPtr:
         case EOpConstructReference:
@@ -1058,6 +959,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             case EOpMin:
                 switch(children[0]->getAsTyped()->getBasicType()) {
                 case EbtFloat16:
+                case EbtBFloat16:
+                case EbtFloatE5M2:
+                case EbtFloatE4M3:
                 case EbtFloat:
                 case EbtDouble:
                     newConstArray[comp].setDConst(std::min(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()));
@@ -1092,6 +996,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             case EOpMax:
                 switch(children[0]->getAsTyped()->getBasicType()) {
                 case EbtFloat16:
+                case EbtBFloat16:
+                case EbtFloatE5M2:
+                case EbtFloatE4M3:
                 case EbtFloat:
                 case EbtDouble:
                     newConstArray[comp].setDConst(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()));
@@ -1126,6 +1033,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             case EOpClamp:
                 switch(children[0]->getAsTyped()->getBasicType()) {
                 case EbtFloat16:
+                case EbtBFloat16:
+                case EbtFloatE5M2:
+                case EbtFloatE4M3:
                 case EbtFloat:
                 case EbtDouble:
                     newConstArray[comp].setDConst(std::min(std::max(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()),
@@ -1233,6 +1143,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             break;
         }
         case EOpDot:
+            if (!children[0]->getAsTyped()->isFloatingDomain()) {
+                return aggrNode;
+            }
             newConstArray[0].setDConst(childConstUnions[0].dot(childConstUnions[1]));
             break;
         case EOpCross:

文件差异内容过多而无法显示
+ 576 - 278
src/libraries/glslang/glslang/MachineIndependent/Initialize.cpp


+ 200 - 331
src/libraries/glslang/glslang/MachineIndependent/Intermediate.cpp

@@ -46,6 +46,7 @@
 #include "propagateNoContraction.h"
 
 #include <cfloat>
+#include <limits>
 #include <utility>
 #include <tuple>
 
@@ -65,10 +66,10 @@ namespace glslang {
 // Returns the added node.
 //
 
-TIntermSymbol* TIntermediate::addSymbol(long long id, const TString& name, const TType& type, const TConstUnionArray& constArray,
+TIntermSymbol* TIntermediate::addSymbol(long long id, const TString& name, const TString& mangledName, const TType& type, const TConstUnionArray& constArray,
                                         TIntermTyped* constSubtree, const TSourceLoc& loc)
 {
-    TIntermSymbol* node = new TIntermSymbol(id, name, type);
+    TIntermSymbol* node = new TIntermSymbol(id, name, getStage(), type, &mangledName);
     node->setLoc(loc);
     node->setConstArray(constArray);
     node->setConstSubtree(constSubtree);
@@ -80,6 +81,7 @@ TIntermSymbol* TIntermediate::addSymbol(const TIntermSymbol& intermSymbol)
 {
     return addSymbol(intermSymbol.getId(),
                      intermSymbol.getName(),
+                     intermSymbol.getMangledName(),
                      intermSymbol.getType(),
                      intermSymbol.getConstArray(),
                      intermSymbol.getConstSubtree(),
@@ -96,14 +98,14 @@ TIntermSymbol* TIntermediate::addSymbol(const TVariable& variable)
 
 TIntermSymbol* TIntermediate::addSymbol(const TVariable& variable, const TSourceLoc& loc)
 {
-    return addSymbol(variable.getUniqueId(), variable.getName(), variable.getType(), variable.getConstArray(), variable.getConstSubtree(), loc);
+    return addSymbol(variable.getUniqueId(), variable.getName(), variable.getMangledName(), variable.getType(), variable.getConstArray(), variable.getConstSubtree(), loc);
 }
 
 TIntermSymbol* TIntermediate::addSymbol(const TType& type, const TSourceLoc& loc)
 {
     TConstUnionArray unionArray;  // just a null constant
 
-    return addSymbol(0, "", type, unionArray, nullptr, loc);
+    return addSymbol(0, "", "", type, unionArray, nullptr, loc);
 }
 
 //
@@ -163,8 +165,8 @@ TIntermTyped* TIntermediate::addBinaryMath(TOperator op, TIntermTyped* left, TIn
         left = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, left, TType(EbtUint64));
         right = addBuiltInFunctionCall(loc, EOpConvPtrToUint64, true, right, TType(EbtUint64));
 
-        left = addBuiltInFunctionCall(loc, EOpConvUint64ToInt64, true, left, TType(EbtInt64));
-        right = addBuiltInFunctionCall(loc, EOpConvUint64ToInt64, true, right, TType(EbtInt64));
+        left = addBuiltInFunctionCall(loc, EOpConvNumeric, true, left, TType(EbtInt64));
+        right = addBuiltInFunctionCall(loc, EOpConvNumeric, true, right, TType(EbtInt64));
 
         left = addBinaryMath(EOpSub, left, right, loc);
 
@@ -397,6 +399,9 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child,
     case EOpConstructUint64: newType = EbtUint64; break;
     case EOpConstructDouble: newType = EbtDouble; break;
     case EOpConstructFloat16: newType = EbtFloat16; break;
+    case EOpConstructBFloat16: newType = EbtBFloat16; break;
+    case EOpConstructFloatE4M3: newType = EbtFloatE4M3; break;
+    case EOpConstructFloatE5M2: newType = EbtFloatE5M2; break;
     default: break; // some compilers want this
     }
 
@@ -426,7 +431,10 @@ TIntermTyped* TIntermediate::addUnaryMath(TOperator op, TIntermTyped* child,
         case EOpConstructBool:
         case EOpConstructFloat:
         case EOpConstructDouble:
-        case EOpConstructFloat16: {
+        case EOpConstructFloat16:
+        case EOpConstructBFloat16:
+        case EOpConstructFloatE5M2:
+        case EOpConstructFloatE4M3: {
             TIntermUnary* unary_node = child->getAsUnaryNode();
             if (unary_node != nullptr)
                 unary_node->updatePrecision();
@@ -567,222 +575,18 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const
 
 bool TIntermediate::buildConvertOp(TBasicType dst, TBasicType src, TOperator& newOp) const
 {
-    switch (dst) {
-    case EbtDouble:
-        switch (src) {
-        case EbtUint:    newOp = EOpConvUintToDouble;    break;
-        case EbtBool:    newOp = EOpConvBoolToDouble;    break;
-        case EbtFloat:   newOp = EOpConvFloatToDouble;   break;
-        case EbtInt:     newOp = EOpConvIntToDouble;     break;
-        case EbtInt8:    newOp = EOpConvInt8ToDouble;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToDouble;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToDouble;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToDouble;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToDouble; break;
-        case EbtInt64:   newOp = EOpConvInt64ToDouble;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToDouble;  break;
-        default:
-            return false;
-        }
-        break;
-    case EbtFloat:
-        switch (src) {
-        case EbtInt:     newOp = EOpConvIntToFloat;     break;
-        case EbtUint:    newOp = EOpConvUintToFloat;    break;
-        case EbtBool:    newOp = EOpConvBoolToFloat;    break;
-        case EbtDouble:  newOp = EOpConvDoubleToFloat;  break;
-        case EbtInt8:    newOp = EOpConvInt8ToFloat;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToFloat;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToFloat;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToFloat;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToFloat; break;
-        case EbtInt64:   newOp = EOpConvInt64ToFloat;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToFloat;  break;
-        default:
-            return false;
-        }
-        break;
-    case EbtFloat16:
-        switch (src) {
-        case EbtInt8:   newOp = EOpConvInt8ToFloat16;   break;
-        case EbtUint8:  newOp = EOpConvUint8ToFloat16;  break;
-        case EbtInt16:  newOp = EOpConvInt16ToFloat16;  break;
-        case EbtUint16: newOp = EOpConvUint16ToFloat16; break;
-        case EbtInt:    newOp = EOpConvIntToFloat16;    break;
-        case EbtUint:   newOp = EOpConvUintToFloat16;   break;
-        case EbtBool:   newOp = EOpConvBoolToFloat16;   break;
-        case EbtFloat:  newOp = EOpConvFloatToFloat16;  break;
-        case EbtDouble: newOp = EOpConvDoubleToFloat16; break;
-        case EbtInt64:  newOp = EOpConvInt64ToFloat16;  break;
-        case EbtUint64: newOp = EOpConvUint64ToFloat16; break;
-        default:
-            return false;
-        }
-        break;
-    case EbtBool:
-        switch (src) {
-        case EbtInt:     newOp = EOpConvIntToBool;     break;
-        case EbtUint:    newOp = EOpConvUintToBool;    break;
-        case EbtFloat:   newOp = EOpConvFloatToBool;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToBool;  break;
-        case EbtInt8:    newOp = EOpConvInt8ToBool;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToBool;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToBool;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToBool;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToBool; break;
-        case EbtInt64:   newOp = EOpConvInt64ToBool;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToBool;  break;
-        default:
-            return false;
-        }
-        break;
-    case EbtInt8:
-        switch (src) {
-        case EbtUint8:   newOp = EOpConvUint8ToInt8;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToInt8;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToInt8;  break;
-        case EbtInt:     newOp = EOpConvIntToInt8;     break;
-        case EbtUint:    newOp = EOpConvUintToInt8;    break;
-        case EbtInt64:   newOp = EOpConvInt64ToInt8;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToInt8;  break;
-        case EbtBool:    newOp = EOpConvBoolToInt8;    break;
-        case EbtFloat:   newOp = EOpConvFloatToInt8;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToInt8;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToInt8; break;
-        default:
-            return false;
-        }
-        break;
-    case EbtUint8:
-        switch (src) {
-        case EbtInt8:    newOp = EOpConvInt8ToUint8;    break;
-        case EbtInt16:   newOp = EOpConvInt16ToUint8;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToUint8;  break;
-        case EbtInt:     newOp = EOpConvIntToUint8;     break;
-        case EbtUint:    newOp = EOpConvUintToUint8;    break;
-        case EbtInt64:   newOp = EOpConvInt64ToUint8;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToUint8;  break;
-        case EbtBool:    newOp = EOpConvBoolToUint8;    break;
-        case EbtFloat:   newOp = EOpConvFloatToUint8;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToUint8;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToUint8; break;
-        default:
-            return false;
-        }
-        break;
-
-    case EbtInt16:
-        switch (src) {
-        case EbtUint8:   newOp = EOpConvUint8ToInt16;   break;
-        case EbtInt8:    newOp = EOpConvInt8ToInt16;    break;
-        case EbtUint16:  newOp = EOpConvUint16ToInt16;  break;
-        case EbtInt:     newOp = EOpConvIntToInt16;     break;
-        case EbtUint:    newOp = EOpConvUintToInt16;    break;
-        case EbtInt64:   newOp = EOpConvInt64ToInt16;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToInt16;  break;
-        case EbtBool:    newOp = EOpConvBoolToInt16;    break;
-        case EbtFloat:   newOp = EOpConvFloatToInt16;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToInt16;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToInt16; break;
-        default:
-            return false;
-        }
-        break;
-    case EbtUint16:
-        switch (src) {
-        case EbtInt8:    newOp = EOpConvInt8ToUint16;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToUint16;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToUint16;   break;
-        case EbtInt:     newOp = EOpConvIntToUint16;     break;
-        case EbtUint:    newOp = EOpConvUintToUint16;    break;
-        case EbtInt64:   newOp = EOpConvInt64ToUint16;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToUint16;  break;
-        case EbtBool:    newOp = EOpConvBoolToUint16;    break;
-        case EbtFloat:   newOp = EOpConvFloatToUint16;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToUint16;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToUint16; break;
-        default:
-            return false;
-        }
-        break;
-
-    case EbtInt:
-        switch (src) {
-        case EbtUint:    newOp = EOpConvUintToInt;    break;
-        case EbtBool:    newOp = EOpConvBoolToInt;    break;
-        case EbtFloat:   newOp = EOpConvFloatToInt;   break;
-        case EbtInt8:    newOp = EOpConvInt8ToInt;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToInt;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToInt;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToInt;  break;
-        case EbtDouble:  newOp = EOpConvDoubleToInt;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToInt; break;
-        case EbtInt64:   newOp = EOpConvInt64ToInt;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToInt;  break;
-        default:
-            return false;
-        }
-        break;
-    case EbtUint:
-        switch (src) {
-        case EbtInt:     newOp = EOpConvIntToUint;     break;
-        case EbtBool:    newOp = EOpConvBoolToUint;    break;
-        case EbtFloat:   newOp = EOpConvFloatToUint;   break;
-        case EbtInt8:    newOp = EOpConvInt8ToUint;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToUint;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToUint;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToUint;  break;
-        case EbtDouble:  newOp = EOpConvDoubleToUint;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToUint; break;
-        case EbtInt64:   newOp = EOpConvInt64ToUint;   break;
-        case EbtUint64:  newOp = EOpConvUint64ToUint;  break;
-        // For bindless texture type conversion, add a dummy convert op, just
-        // to generate a new TIntermTyped
-        // uvec2(any sampler type)
-        // uvec2(any image type)
-        case EbtSampler: newOp = EOpConvIntToUint;  break;
-        default:
-            return false;
-        }
-        break;
-    case EbtInt64:
-        switch (src) {
-        case EbtInt8:    newOp = EOpConvInt8ToInt64;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToInt64;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToInt64;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToInt64;  break;
-        case EbtInt:     newOp = EOpConvIntToInt64;     break;
-        case EbtUint:    newOp = EOpConvUintToInt64;    break;
-        case EbtBool:    newOp = EOpConvBoolToInt64;    break;
-        case EbtFloat:   newOp = EOpConvFloatToInt64;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToInt64;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToInt64; break;
-        case EbtUint64:  newOp = EOpConvUint64ToInt64;  break;
-        default:
-            return false;
-        }
-        break;
-    case EbtUint64:
-        switch (src) {
-        case EbtInt8:    newOp = EOpConvInt8ToUint64;    break;
-        case EbtUint8:   newOp = EOpConvUint8ToUint64;   break;
-        case EbtInt16:   newOp = EOpConvInt16ToUint64;   break;
-        case EbtUint16:  newOp = EOpConvUint16ToUint64;  break;
-        case EbtInt:     newOp = EOpConvIntToUint64;     break;
-        case EbtUint:    newOp = EOpConvUintToUint64;    break;
-        case EbtBool:    newOp = EOpConvBoolToUint64;    break;
-        case EbtFloat:   newOp = EOpConvFloatToUint64;   break;
-        case EbtDouble:  newOp = EOpConvDoubleToUint64;  break;
-        case EbtFloat16: newOp = EOpConvFloat16ToUint64; break;
-        case EbtInt64:   newOp = EOpConvInt64ToUint64;   break;
-        default:
-            return false;
-        }
-        break;
-    default:
+    // (bfloat16_t,fp8) <-> bool not supported
+    if (((src == EbtBFloat16 || src == EbtFloatE5M2 || src == EbtFloatE4M3) && dst == EbtBool) ||
+        ((dst == EbtBFloat16 || dst == EbtFloatE5M2 || dst == EbtFloatE4M3) && src == EbtBool)) {
         return false;
     }
-    return true;
+
+    if ((isTypeInt(dst) || isTypeFloat(dst) || dst == EbtBool) &&
+        (isTypeInt(src) || isTypeFloat(src) || src == EbtBool)) {
+        newOp = EOpConvNumeric;
+        return true;
+    }
+    return false;
 }
 
 // This is 'mechanism' here, it does any conversion told.
@@ -804,11 +608,15 @@ TIntermTyped* TIntermediate::createConversion(TBasicType convertTo, TIntermTyped
                                 node->getBasicType() == EbtInt   || node->getBasicType() == EbtUint   ||
                                 node->getBasicType() == EbtInt64 || node->getBasicType() == EbtUint64);
 
-    bool convertToFloatTypes = (convertTo == EbtFloat16 || convertTo == EbtFloat || convertTo == EbtDouble);
+    bool convertToFloatTypes = (convertTo == EbtFloat16 || convertTo == EbtBFloat16 || convertTo == EbtFloat || convertTo == EbtDouble ||
+                                convertTo == EbtFloatE5M2 || convertTo == EbtFloatE4M3);
 
     bool convertFromFloatTypes = (node->getBasicType() == EbtFloat16 ||
+                                  node->getBasicType() == EbtBFloat16 ||
                                   node->getBasicType() == EbtFloat ||
-                                  node->getBasicType() == EbtDouble);
+                                  node->getBasicType() == EbtDouble ||
+                                  node->getBasicType() == EbtFloatE5M2 ||
+                                  node->getBasicType() == EbtFloatE4M3);
 
     if (((convertTo == EbtInt8 || convertTo == EbtUint8) && ! convertFromIntTypes) ||
         ((node->getBasicType() == EbtInt8 || node->getBasicType() == EbtUint8) && ! convertToIntTypes)) {
@@ -1034,6 +842,15 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         op != EOpConstructCooperativeMatrixKHR)
         return nullptr;
 
+    if (node->getType().isTensorLayoutNV() ||
+        node->getType().isTensorViewNV())
+        return nullptr;
+
+    // Reject implicit conversions to cooperative vector types
+    if (node->getType().isCoopVecNV() &&
+        op != EOpConstructCooperativeVectorNV)
+        return nullptr;
+
     // Note: callers are responsible for other aspects of shape,
     // like vector and matrix sizes.
 
@@ -1047,12 +864,16 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     case EOpConstructUint:
     case EOpConstructDouble:
     case EOpConstructFloat16:
+    case EOpConstructBFloat16:
+    case EOpConstructFloatE5M2:
+    case EOpConstructFloatE4M3:
     case EOpConstructInt8:
     case EOpConstructUint8:
     case EOpConstructInt16:
     case EOpConstructUint16:
     case EOpConstructInt64:
     case EOpConstructUint64:
+    case EOpConstructSaturated:
         break;
 
     //
@@ -1101,6 +922,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     case EOpConstructStruct:
     case EOpConstructCooperativeMatrixNV:
     case EOpConstructCooperativeMatrixKHR:
+    case EOpConstructCooperativeVectorNV:
 
         if (type.isReference() || node->getType().isReference()) {
             // types must match to assign a reference
@@ -1152,6 +974,11 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     //    changing language sementics on the fly by asking what extensions are in use
     //  - at the time of this writing (14-Aug-2020), no test results are changed by this.
     switch (op) {
+    case EOpConstructBFloat16:
+    case EOpConstructFloatE5M2:
+    case EOpConstructFloatE4M3:
+        canPromoteConstant = true;
+        break;
     case EOpConstructFloat16:
         canPromoteConstant = numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
                              numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_float16);
@@ -1454,6 +1281,9 @@ bool TIntermediate::isFPPromotion(TBasicType from, TBasicType to) const
     // floating-point promotions
     if (to == EbtDouble) {
         switch(from) {
+        case EbtBFloat16:
+        case EbtFloatE5M2:
+        case EbtFloatE4M3:
         case EbtFloat16:
         case EbtFloat:
             return true;
@@ -1546,7 +1376,7 @@ bool TIntermediate::isIntegralConversion(TBasicType from, TBasicType to) const
 
 bool TIntermediate::isFPConversion(TBasicType from, TBasicType to) const
 {
-    if (to == EbtFloat && from == EbtFloat16) {
+    if (to == EbtFloat && (from == EbtFloat16 || from == EbtBFloat16 || from == EbtFloatE5M2 || from == EbtFloatE4M3)) {
         return true;
     } else {
         return false;
@@ -1694,10 +1524,19 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             case EbtInt16:
             case EbtUint16:
                 return (version >= 400 || numericFeatures.contains(TNumericFeatures::gpu_shader_fp64)) &&
-                                          numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+                                         (numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) || 
+                                          numericFeatures.contains(TNumericFeatures::gpu_shader_int16));
             case EbtFloat16:
                 return (version >= 400 || numericFeatures.contains(TNumericFeatures::gpu_shader_fp64)) &&
-                                          numericFeatures.contains(TNumericFeatures::gpu_shader_half_float);
+                                        (numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) || 
+                                        numericFeatures.contains(TNumericFeatures::gpu_shader_half_float));
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+                return true;
+            case EbtInt8:
+            case EbtUint8:
+                return numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             default:
                 return false;
            }
@@ -1710,22 +1549,37 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
                  return getSource() == EShSourceHlsl;
             case EbtInt16:
             case EbtUint16:
-                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+                       numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             case EbtFloat16:
                 return numericFeatures.contains(TNumericFeatures::gpu_shader_half_float) ||
+                    numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                     getSource() == EShSourceHlsl;
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+                return true;
+            case EbtInt8:
+            case EbtUint8:
+                return numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             default:
                  return false;
             }
         case EbtUint:
             switch (from) {
             case EbtInt:
-                return version >= 400 || getSource() == EShSourceHlsl || IsRequestedExtension(E_GL_ARB_gpu_shader5);
+                return version >= 400 || getSource() == EShSourceHlsl || 
+						IsRequestedExtension(E_GL_ARB_gpu_shader5) ||
+						numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             case EbtBool:
                 return getSource() == EShSourceHlsl;
             case EbtInt16:
             case EbtUint16:
-                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+                       numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
+            case EbtInt8:
+            case EbtUint8:
+                return numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             default:
                 return false;
             }
@@ -1734,7 +1588,10 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             case EbtBool:
                 return getSource() == EShSourceHlsl;
             case EbtInt16:
-                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+                       numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
+            case EbtInt8:
+                return numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             default:
                 return false;
             }
@@ -1746,7 +1603,11 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
                 return true;
             case EbtInt16:
             case EbtUint16:
-                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+                	numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
+            case EbtInt8:
+            case EbtUint8:
+                return numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             default:
                 return false;
             }
@@ -1754,8 +1615,11 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             switch (from) {
             case EbtInt:
                 return true;
+            case EbtInt8:
+                return numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             case EbtInt16:
-                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+                return numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+				       numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types);
             default:
                 return false;
             }
@@ -1764,6 +1628,18 @@ bool TIntermediate::canImplicitlyPromote(TBasicType from, TBasicType to, TOperat
             case EbtInt16:
             case EbtUint16:
                 return numericFeatures.contains(TNumericFeatures::gpu_shader_int16);
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+                return true;
+            default:
+                break;
+            }
+            return false;
+        case EbtBFloat16:
+            switch (from) {
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
+                return true;
             default:
                 break;
             }
@@ -1922,6 +1798,10 @@ std::tuple<TBasicType, TBasicType> TIntermediate::getConversionDestinationType(T
                (type1 == EbtFloat16 && canImplicitlyPromote(type0, EbtFloat16, op)) ) {
         res0 = EbtFloat16;
         res1 = EbtFloat16;
+    } else if ((type0 == EbtBFloat16 && canImplicitlyPromote(type1, EbtBFloat16, op)) ||
+               (type1 == EbtBFloat16 && canImplicitlyPromote(type0, EbtBFloat16, op)) ) {
+        res0 = EbtBFloat16;
+        res1 = EbtBFloat16;
     } else if (isTypeInt(type0) && isTypeInt(type1) &&
                (canImplicitlyPromote(type0, type1, op) || canImplicitlyPromote(type1, type0, op))) {
         if ((isTypeSignedInt(type0) && isTypeSignedInt(type1)) ||
@@ -1977,6 +1857,9 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const
     if (type.isCoopMatKHR())
         return EOpConstructCooperativeMatrixKHR;
 
+    if (type.isCoopVecNV())
+        return EOpConstructCooperativeVectorNV;
+
     switch (type.getBasicType()) {
     case EbtStruct:
         op = EOpConstructStruct;
@@ -2215,6 +2098,33 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const
             }
         }
         break;
+    case EbtBFloat16:
+        switch (type.getVectorSize()) {
+        case 1: op = EOpConstructBFloat16;  break;
+        case 2: op = EOpConstructBF16Vec2;  break;
+        case 3: op = EOpConstructBF16Vec3;  break;
+        case 4: op = EOpConstructBF16Vec4;  break;
+        default: break; // some compilers want this
+        }
+        break;
+    case EbtFloatE5M2:
+        switch (type.getVectorSize()) {
+        case 1: op = EOpConstructFloatE5M2;  break;
+        case 2: op = EOpConstructFloatE5M2Vec2;  break;
+        case 3: op = EOpConstructFloatE5M2Vec3;  break;
+        case 4: op = EOpConstructFloatE5M2Vec4;  break;
+        default: break; // some compilers want this
+        }
+        break;
+    case EbtFloatE4M3:
+        switch (type.getVectorSize()) {
+        case 1: op = EOpConstructFloatE4M3;  break;
+        case 2: op = EOpConstructFloatE4M3Vec2;  break;
+        case 3: op = EOpConstructFloatE4M3Vec3;  break;
+        case 4: op = EOpConstructFloatE4M3Vec4;  break;
+        default: break; // some compilers want this
+        }
+        break;
     case EbtInt8:
         switch(type.getVectorSize()) {
         case 1: op = EOpConstructInt8;   break;
@@ -2624,7 +2534,7 @@ TIntermConstantUnion* TIntermediate::addConstantUnion(bool b, const TSourceLoc&
 
 TIntermConstantUnion* TIntermediate::addConstantUnion(double d, TBasicType baseType, const TSourceLoc& loc, bool literal) const
 {
-    assert(baseType == EbtFloat || baseType == EbtDouble || baseType == EbtFloat16);
+    assert(baseType == EbtFloat || baseType == EbtDouble || baseType == EbtFloat16 || baseType == EbtBFloat16 || baseType == EbtFloatE5M2 || baseType == EbtFloatE4M3);
 
     if (isEsProfile() && (baseType == EbtFloat || baseType == EbtFloat16)) {
         int exponent = 0;
@@ -2962,17 +2872,16 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const
     // (However, some floating-point operations result in bool, like ">",
     // so are handled later.)
     if (node.getType().isFloatingDomain()) {
+        if (IsOpNumericConv(node.getOp()) &&
+            isTypeFloat(node.getType().getBasicType()) &&
+            isTypeFloat(node.getAsUnaryNode()->getOperand()->getAsTyped()->getType().getBasicType())) {
+            return true;
+        }
         switch (node.getOp()) {
         case EOpIndexDirect:
         case EOpIndexIndirect:
         case EOpIndexDirectStruct:
         case EOpVectorSwizzle:
-        case EOpConvFloatToDouble:
-        case EOpConvDoubleToFloat:
-        case EOpConvFloat16ToFloat:
-        case EOpConvFloatToFloat16:
-        case EOpConvFloat16ToDouble:
-        case EOpConvDoubleToFloat16:
             return true;
         default:
             return false;
@@ -2987,6 +2896,15 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const
 
     // So, for now, we can assume everything left is non-floating-point...
 
+    if (IsOpNumericConv(node.getOp())) {
+        TBasicType srcType = node.getAsUnaryNode()->getOperand()->getAsTyped()->getType().getBasicType();
+        TBasicType dstType = node.getType().getBasicType();
+        if ((isTypeInt(srcType) || srcType == EbtBool) &&
+            (isTypeInt(dstType) || dstType == EbtBool)) {
+            return true;
+        }
+    }
+
     // Now check for integer/bool-based operations
     switch (node.getOp()) {
 
@@ -2996,98 +2914,6 @@ bool TIntermediate::isSpecializationOperation(const TIntermOperator& node) const
     case EOpIndexDirectStruct:
     case EOpVectorSwizzle:
 
-    // (u)int* -> bool
-    case EOpConvInt8ToBool:
-    case EOpConvInt16ToBool:
-    case EOpConvIntToBool:
-    case EOpConvInt64ToBool:
-    case EOpConvUint8ToBool:
-    case EOpConvUint16ToBool:
-    case EOpConvUintToBool:
-    case EOpConvUint64ToBool:
-
-    // bool -> (u)int*
-    case EOpConvBoolToInt8:
-    case EOpConvBoolToInt16:
-    case EOpConvBoolToInt:
-    case EOpConvBoolToInt64:
-    case EOpConvBoolToUint8:
-    case EOpConvBoolToUint16:
-    case EOpConvBoolToUint:
-    case EOpConvBoolToUint64:
-
-    // int8_t -> (u)int*
-    case EOpConvInt8ToInt16:
-    case EOpConvInt8ToInt:
-    case EOpConvInt8ToInt64:
-    case EOpConvInt8ToUint8:
-    case EOpConvInt8ToUint16:
-    case EOpConvInt8ToUint:
-    case EOpConvInt8ToUint64:
-
-    // int16_t -> (u)int*
-    case EOpConvInt16ToInt8:
-    case EOpConvInt16ToInt:
-    case EOpConvInt16ToInt64:
-    case EOpConvInt16ToUint8:
-    case EOpConvInt16ToUint16:
-    case EOpConvInt16ToUint:
-    case EOpConvInt16ToUint64:
-
-    // int32_t -> (u)int*
-    case EOpConvIntToInt8:
-    case EOpConvIntToInt16:
-    case EOpConvIntToInt64:
-    case EOpConvIntToUint8:
-    case EOpConvIntToUint16:
-    case EOpConvIntToUint:
-    case EOpConvIntToUint64:
-
-    // int64_t -> (u)int*
-    case EOpConvInt64ToInt8:
-    case EOpConvInt64ToInt16:
-    case EOpConvInt64ToInt:
-    case EOpConvInt64ToUint8:
-    case EOpConvInt64ToUint16:
-    case EOpConvInt64ToUint:
-    case EOpConvInt64ToUint64:
-
-    // uint8_t -> (u)int*
-    case EOpConvUint8ToInt8:
-    case EOpConvUint8ToInt16:
-    case EOpConvUint8ToInt:
-    case EOpConvUint8ToInt64:
-    case EOpConvUint8ToUint16:
-    case EOpConvUint8ToUint:
-    case EOpConvUint8ToUint64:
-
-    // uint16_t -> (u)int*
-    case EOpConvUint16ToInt8:
-    case EOpConvUint16ToInt16:
-    case EOpConvUint16ToInt:
-    case EOpConvUint16ToInt64:
-    case EOpConvUint16ToUint8:
-    case EOpConvUint16ToUint:
-    case EOpConvUint16ToUint64:
-
-    // uint32_t -> (u)int*
-    case EOpConvUintToInt8:
-    case EOpConvUintToInt16:
-    case EOpConvUintToInt:
-    case EOpConvUintToInt64:
-    case EOpConvUintToUint8:
-    case EOpConvUintToUint16:
-    case EOpConvUintToUint64:
-
-    // uint64_t -> (u)int*
-    case EOpConvUint64ToInt8:
-    case EOpConvUint64ToInt16:
-    case EOpConvUint64ToInt:
-    case EOpConvUint64ToInt64:
-    case EOpConvUint64ToUint8:
-    case EOpConvUint64ToUint16:
-    case EOpConvUint64ToUint:
-
     // unary operations
     case EOpNegative:
     case EOpLogicalNot:
@@ -3590,6 +3416,43 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
         return false;
     }
 
+    if (left->getType().isCoopVecNV() || right->getType().isCoopVecNV()) {
+        // Operations on two cooperative vectors must have identical types
+        if (left->getType().isCoopVecNV() && right->getType().isCoopVecNV() &&
+            left->getType() != right->getType()) {
+            return false;
+        }
+        switch (op) {
+        case EOpMul:
+        case EOpMulAssign:
+            // Use VectorTimesScalar if either operand is not a vector. Otherwise use Mul.
+            if (!left->getType().isCoopVecNV() || !right->getType().isCoopVecNV()) {
+                node.setOp(op == EOpMulAssign ? EOpVectorTimesScalarAssign : EOpVectorTimesScalar);
+            }
+            // In case of scalar*vector, take the result type from the vector.
+            if (right->getType().isCoopVecNV()) {
+                node.setType(right->getType());
+            }
+            return true;
+        case EOpLeftShift:
+        case EOpLeftShiftAssign:
+        case EOpRightShift:
+        case EOpRightShiftAssign:
+        case EOpAdd:
+        case EOpSub:
+        case EOpDiv:
+        case EOpAssign:
+            // These require both to be cooperative vectors
+            if (!left->getType().isCoopVecNV() || !right->getType().isCoopVecNV()) {
+                return false;
+            }
+            return true;
+        default:
+            break;
+        }
+        return false;
+    }
+
     // Finish handling the case, for all ops, where both operands are scalars.
     if (left->isScalar() && right->isScalar())
         return true;
@@ -3925,6 +3788,9 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
 
 #define TO_ALL(Get)   \
         switch (promoteTo) { \
+        case EbtBFloat16: PROMOTE(setDConst, double, Get); break; \
+        case EbtFloatE5M2: PROMOTE(setDConst, double, Get); break; \
+        case EbtFloatE4M3: PROMOTE(setDConst, double, Get); break; \
         case EbtFloat16: PROMOTE(setDConst, double, Get); break; \
         case EbtFloat: PROMOTE(setDConst, double, Get); break; \
         case EbtDouble: PROMOTE(setDConst, double, Get); break; \
@@ -3946,6 +3812,9 @@ TIntermTyped* TIntermediate::promoteConstantUnion(TBasicType promoteTo, TIntermC
         case EbtUint: TO_ALL(getUConst); break;
         case EbtBool: TO_ALL(getBConst); break;
         case EbtFloat16: TO_ALL(getDConst); break;
+        case EbtBFloat16: TO_ALL(getDConst); break;
+        case EbtFloatE5M2: TO_ALL(getDConst); break;
+        case EbtFloatE4M3: TO_ALL(getDConst); break;
         case EbtDouble: TO_ALL(getDConst); break;
         case EbtInt8: TO_ALL(getI8Const); break;
         case EbtInt16: TO_ALL(getI16Const); break;

+ 41 - 0
src/libraries/glslang/glslang/MachineIndependent/LiveTraverser.h

@@ -132,6 +132,47 @@ protected:
             return true; // traverse the whole subtree
     }
 
+    // To prune semantically dead paths in switch statements with constant expressions.
+    virtual bool visitSwitch(TVisit /* visit */, TIntermSwitch* node)
+    {
+        if (traverseAll)
+            return true; // traverse all code
+
+        TIntermConstantUnion* constant = node->getCondition()->getAsConstantUnion();
+        if (constant) {
+            TConstUnion switchValue = constant->getConstArray()[0];
+            int liveBranch = -1;
+            const auto& body = node->getBody()->getSequence();
+            for (unsigned int i = 0; i < body.size(); ++i) {
+                if (body[i]->getAsBranchNode()) {
+                    if (body[i]->getAsBranchNode()->getFlowOp() == glslang::EOpCase) {
+                        TConstUnion caseValue =
+                            body[i]->getAsBranchNode()->getExpression()->getAsConstantUnion()->getConstArray()[0];
+                        if (switchValue == caseValue.getIConst()) {
+                            liveBranch = (int)i;
+                            break;
+                        }
+                    } else if (body[i]->getAsBranchNode()->getFlowOp() == glslang::EOpDefault) {
+                        liveBranch = (int)i;
+                    }
+                }
+            }
+            if (liveBranch != -1) {
+                for (int i = liveBranch; i < (int)body.size(); ++i) {
+                    if (body[i]->getAsAggregate()) {
+                        for (auto* inst : body[i]->getAsAggregate()->getSequence()) {
+                            if (inst->getAsBranchNode() && (inst->getAsBranchNode()->getFlowOp() == glslang::EOpBreak))
+                                return false; // found and traversed the live case(s)
+                            inst->traverse(this);
+                        }
+                    }
+                }
+            }
+            return false; // finished traversing all cases
+        } else
+            return true; // traverse the whole subtree
+    }
+
     // Track live functions as well as uniforms, so that we don't visit dead functions
     // and only visit each function once.
     void addFunctionCall(TIntermAggregate* call)

+ 5 - 0
src/libraries/glslang/glslang/MachineIndependent/ParseContextBase.cpp

@@ -305,6 +305,11 @@ void TParseContextBase::checkIndex(const TSourceLoc& loc, const TType& type, int
             error(loc, "", "[", "matrix index out of range '%d'", index);
             index = type.getMatrixCols() - 1;
         }
+    } else if (type.isCoopVecNV()) {
+        if (index >= type.computeNumComponents()) {
+            error(loc, "", "[", "cooperative vector index out of range '%d'", index);
+            index = type.computeNumComponents() - 1;
+        }
     }
 }
 

文件差异内容过多而无法显示
+ 544 - 54
src/libraries/glslang/glslang/MachineIndependent/ParseHelper.cpp


+ 5 - 3
src/libraries/glslang/glslang/MachineIndependent/ParseHelper.h

@@ -384,7 +384,7 @@ public:
     void globalCheck(const TSourceLoc&, const char* token);
     bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&);
     bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&);
-    void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType, const bool allowZero = false);
+    void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&, const char *sizeType, const bool isTypeParameter = false);
     bool arrayQualifierError(const TSourceLoc&, const TQualifier&);
     bool arrayError(const TSourceLoc&, const TType&);
     void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&);
@@ -397,6 +397,7 @@ public:
     void samplerCheck(const TSourceLoc&, const TType&, const TString& identifier, TIntermTyped* initializer);
     void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier);
     void accStructCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
+    void hitObjectNVCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
     void transparentOpaqueCheck(const TSourceLoc&, const TType&, const TString& identifier);
     void memberQualifierCheck(glslang::TPublicType&);
     void globalQualifierFixCheck(const TSourceLoc&, TQualifier&, bool isMemberCheck = false, const TPublicType* publicType = nullptr);
@@ -406,7 +407,7 @@ public:
     void setDefaultPrecision(const TSourceLoc&, TPublicType&, TPrecisionQualifier);
     int computeSamplerTypeIndex(TSampler&);
     TPrecisionQualifier getDefaultPrecision(TPublicType&);
-    void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMat);
+    void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMatOrVec);
     void parameterTypeCheck(const TSourceLoc&, TStorageQualifier qualifier, const TType& type);
     bool containsFieldWithBasicType(const TType& type ,TBasicType basicType);
     TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&);
@@ -424,7 +425,7 @@ public:
     void inductiveLoopCheck(const TSourceLoc&, TIntermNode* init, TIntermLoop* loop);
     void arrayLimitCheck(const TSourceLoc&, const TString&, int size);
     void limitCheck(const TSourceLoc&, int value, const char* limit, const char* feature);
-    void coopMatTypeParametersCheck(const TSourceLoc&, const TPublicType&);
+    void typeParametersCheck(const TSourceLoc&, const TPublicType&);
 
     void inductiveLoopBodyCheck(TIntermNode*, long long loopIndexId, TSymbolTable&);
     void constantIndexExpressionCheck(TIntermNode*);
@@ -508,6 +509,7 @@ protected:
     TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable);
     TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer);
     void finish() override;
+    void handleCoopMat2FunctionCall(const TSourceLoc& loc, const TFunction* fnCandidate, TIntermTyped* result, TIntermNode* arguments);
 
     virtual const char* getGlobalUniformBlockName() const override;
     virtual void finalizeGlobalUniformBlockLayout(TVariable&) override;

文件差异内容过多而无法显示
+ 493 - 493
src/libraries/glslang/glslang/MachineIndependent/Scan.cpp


+ 98 - 42
src/libraries/glslang/glslang/MachineIndependent/ShaderLang.cpp

@@ -297,18 +297,21 @@ int CommonIndex(EProfile profile, EShLanguage language)
 //
 // To initialize per-stage shared tables, with the common table already complete.
 //
-void InitializeStageSymbolTable(TBuiltInParseables& builtInParseables, int version, EProfile profile, const SpvVersion& spvVersion,
+bool InitializeStageSymbolTable(TBuiltInParseables& builtInParseables, int version, EProfile profile, const SpvVersion& spvVersion,
                                 EShLanguage language, EShSource source, TInfoSink& infoSink, TSymbolTable** commonTable,
                                 TSymbolTable** symbolTables)
 {
     (*symbolTables[language]).adoptLevels(*commonTable[CommonIndex(profile, language)]);
-    InitializeSymbolTable(builtInParseables.getStageString(language), version, profile, spvVersion, language, source,
-                          infoSink, *symbolTables[language]);
+    if (!InitializeSymbolTable(builtInParseables.getStageString(language), version, profile, spvVersion, language, source,
+                          infoSink, *symbolTables[language]))
+        return false;
     builtInParseables.identifyBuiltIns(version, profile, spvVersion, language, *symbolTables[language]);
     if (profile == EEsProfile && version >= 300)
         (*symbolTables[language]).setNoBuiltInRedeclarations();
     if (version == 110)
         (*symbolTables[language]).setSeparateNameSpaces();
+
+    return true;
 }
 
 //
@@ -317,6 +320,7 @@ void InitializeStageSymbolTable(TBuiltInParseables& builtInParseables, int versi
 //
 bool InitializeSymbolTables(TInfoSink& infoSink, TSymbolTable** commonTable,  TSymbolTable** symbolTables, int version, EProfile profile, const SpvVersion& spvVersion, EShSource source)
 {
+    bool success = true;
     std::unique_ptr<TBuiltInParseables> builtInParseables(CreateBuiltInParseables(infoSink, source));
 
     if (builtInParseables == nullptr)
@@ -325,70 +329,70 @@ bool InitializeSymbolTables(TInfoSink& infoSink, TSymbolTable** commonTable,  TS
     builtInParseables->initialize(version, profile, spvVersion);
 
     // do the common tables
-    InitializeSymbolTable(builtInParseables->getCommonString(), version, profile, spvVersion, EShLangVertex, source,
+    success &= InitializeSymbolTable(builtInParseables->getCommonString(), version, profile, spvVersion, EShLangVertex, source,
                           infoSink, *commonTable[EPcGeneral]);
     if (profile == EEsProfile)
-        InitializeSymbolTable(builtInParseables->getCommonString(), version, profile, spvVersion, EShLangFragment, source,
+        success &= InitializeSymbolTable(builtInParseables->getCommonString(), version, profile, spvVersion, EShLangFragment, source,
                               infoSink, *commonTable[EPcFragment]);
 
     // do the per-stage tables
 
     // always have vertex and fragment
-    InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangVertex, source,
+    success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangVertex, source,
                                infoSink, commonTable, symbolTables);
-    InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangFragment, source,
+    success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangFragment, source,
                                infoSink, commonTable, symbolTables);
 
     // check for tessellation
     if ((profile != EEsProfile && version >= 150) ||
         (profile == EEsProfile && version >= 310)) {
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTessControl, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTessControl, source,
                                    infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTessEvaluation, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTessEvaluation, source,
                                    infoSink, commonTable, symbolTables);
     }
 
     // check for geometry
     if ((profile != EEsProfile && version >= 150) ||
         (profile == EEsProfile && version >= 310))
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangGeometry, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangGeometry, source,
                                    infoSink, commonTable, symbolTables);
 
     // check for compute
     if ((profile != EEsProfile && version >= 420) ||
         (profile == EEsProfile && version >= 310))
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCompute, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCompute, source,
                                    infoSink, commonTable, symbolTables);
 
     // check for ray tracing stages
     if (profile != EEsProfile && version >= 450) {
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangRayGen, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangRayGen, source,
             infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangIntersect, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangIntersect, source,
             infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangAnyHit, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangAnyHit, source,
             infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangClosestHit, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangClosestHit, source,
             infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMiss, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMiss, source,
             infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCallable, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCallable, source,
             infoSink, commonTable, symbolTables);
     }
 
     // check for mesh
     if ((profile != EEsProfile && version >= 450) ||
         (profile == EEsProfile && version >= 320))
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMesh, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMesh, source,
                                    infoSink, commonTable, symbolTables);
 
     // check for task
     if ((profile != EEsProfile && version >= 450) ||
         (profile == EEsProfile && version >= 320))
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTask, source,
+        success &= InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangTask, source,
                                    infoSink, commonTable, symbolTables);
 
-    return true;
+    return success;
 }
 
 bool AddContextSpecificSymbols(const TBuiltInResource* resources, TInfoSink& infoSink, TSymbolTable& symbolTable, int version,
@@ -400,7 +404,8 @@ bool AddContextSpecificSymbols(const TBuiltInResource* resources, TInfoSink& inf
         return false;
 
     builtInParseables->initialize(*resources, version, profile, spvVersion, language);
-    InitializeSymbolTable(builtInParseables->getCommonString(), version, profile, spvVersion, language, source, infoSink, symbolTable);
+    if (!InitializeSymbolTable(builtInParseables->getCommonString(), version, profile, spvVersion, language, source, infoSink, symbolTable))
+        return false;
     builtInParseables->identifyBuiltIns(version, profile, spvVersion, language, symbolTable, *resources);
 
     return true;
@@ -418,9 +423,10 @@ bool AddContextSpecificSymbols(const TBuiltInResource* resources, TInfoSink& inf
 // This only gets done the first time any thread needs a particular symbol table
 // (lazy evaluation).
 //
-void SetupBuiltinSymbolTable(int version, EProfile profile, const SpvVersion& spvVersion, EShSource source)
+bool SetupBuiltinSymbolTable(int version, EProfile profile, const SpvVersion& spvVersion, EShSource source)
 {
     TInfoSink infoSink;
+    bool success;
 
     // Make sure only one thread tries to do this at a time
 #ifndef DISABLE_THREAD_SUPPORT
@@ -432,8 +438,9 @@ void SetupBuiltinSymbolTable(int version, EProfile profile, const SpvVersion& sp
     int spvVersionIndex = MapSpvVersionToIndex(spvVersion);
     int profileIndex = MapProfileToIndex(profile);
     int sourceIndex = MapSourceToIndex(source);
-    if (CommonSymbolTable[versionIndex][spvVersionIndex][profileIndex][sourceIndex][EPcGeneral])
-        return;
+    if (CommonSymbolTable[versionIndex][spvVersionIndex][profileIndex][sourceIndex][EPcGeneral]) {
+        return true;
+    }
 
     // Switch to a new pool
     TPoolAllocator& previousAllocator = GetThreadPoolAllocator();
@@ -449,7 +456,10 @@ void SetupBuiltinSymbolTable(int version, EProfile profile, const SpvVersion& sp
         stageTables[stage] = new TSymbolTable;
 
     // Generate the local symbol tables using the new pool
-    InitializeSymbolTables(infoSink, commonTable, stageTables, version, profile, spvVersion, source);
+    if (!InitializeSymbolTables(infoSink, commonTable, stageTables, version, profile, spvVersion, source)) {
+        success = false;
+        goto cleanup;
+    }
 
     // Switch to the process-global pool
     SetThreadPoolAllocator(PerProcessGPA);
@@ -471,7 +481,9 @@ void SetupBuiltinSymbolTable(int version, EProfile profile, const SpvVersion& sp
             SharedSymbolTables[versionIndex][spvVersionIndex][profileIndex][sourceIndex][stage]->readOnly();
         }
     }
+    success = true;
 
+cleanup:
     // Clean up the local tables before deleting the pool they used.
     for (int precClass = 0; precClass < EPcCount; ++precClass)
         delete commonTable[precClass];
@@ -480,6 +492,8 @@ void SetupBuiltinSymbolTable(int version, EProfile profile, const SpvVersion& sp
 
     delete builtInPoolAllocator;
     SetThreadPoolAllocator(&previousAllocator);
+
+    return success;
 }
 
 // Function to Print all builtins
@@ -915,7 +929,9 @@ bool ProcessDeferred(
             intermediate.addSourceText(strings[numPre + s], lengths[numPre + s]);
         }
     }
-    SetupBuiltinSymbolTable(version, profile, spvVersion, source);
+    if (!SetupBuiltinSymbolTable(version, profile, spvVersion, source)) {
+        return false;
+    }
 
     TSymbolTable* cachedTable = SharedSymbolTables[MapVersionToIndex(version)]
                                                   [MapSpvVersionToIndex(spvVersion)]
@@ -1324,11 +1340,6 @@ int ShInitialize()
     if (PerProcessGPA == nullptr)
         PerProcessGPA = new TPoolAllocator();
 
-    glslang::TScanContext::fillInKeywordMap();
-#ifdef ENABLE_HLSL
-    glslang::HlslScanContext::fillInKeywordMap();
-#endif
-
     return 1;
 }
 
@@ -1417,11 +1428,6 @@ int ShFinalize()
         PerProcessGPA = nullptr;
     }
 
-    glslang::TScanContext::deleteKeywordMap();
-#ifdef ENABLE_HLSL
-    glslang::HlslScanContext::deleteKeywordMap();
-#endif
-
     return 1;
 }
 
@@ -1726,6 +1732,10 @@ public:
     virtual bool compile(TIntermNode*, int = 0, EProfile = ENoProfile) { return true; }
 };
 
+TIoMapper* GetGlslIoMapper() {
+    return static_cast<TIoMapper*>(new TGlslIoMapper());
+}
+
 TShader::TShader(EShLanguage s)
     : stage(s), lengths(nullptr), stringNames(nullptr), preamble(""), overrideVersion(0)
 {
@@ -1858,6 +1868,9 @@ void TShader::setGlobalUniformBinding(unsigned int binding) { intermediate->setG
 void TShader::setAtomicCounterBlockName(const char* name) { intermediate->setAtomicCounterBlockName(name); }
 void TShader::setAtomicCounterBlockSet(unsigned int set) { intermediate->setAtomicCounterBlockSet(set); }
 
+void TShader::addSourceText(const char* text, size_t len) { intermediate->addSourceText(text, len); }
+void TShader::setSourceFile(const char* file) { intermediate->setSourceFile(file); }
+
 #ifdef ENABLE_HLSL
 // See comment above TDefaultHlslIoMapper in iomapper.cpp:
 void TShader::setHlslIoMapping(bool hlslIoMap)          { intermediate->setHlslIoMapping(hlslIoMap); }
@@ -1966,6 +1979,14 @@ bool TProgram::link(EShMessages messages)
             error = true;
     }
 
+    if (messages & EShMsgAST) {
+        for (int s = 0; s < EShLangCount; ++s) {
+            if (intermediate[s] == nullptr)
+                continue;
+            intermediate[s]->output(*infoSink, true);
+        }
+    }
+
     return ! error;
 }
 
@@ -2031,9 +2052,6 @@ bool TProgram::linkStage(EShLanguage stage, EShMessages messages)
     }
     intermediate[stage]->finalCheck(*infoSink, (messages & EShMsgKeepUncalled) != 0);
 
-    if (messages & EShMsgAST)
-        intermediate[stage]->output(*infoSink, true);
-
     return intermediate[stage]->getNumErrors() == 0;
 }
 
@@ -2057,9 +2075,27 @@ bool TProgram::crossStageCheck(EShMessages messages) {
             activeStages.push_back(intermediate[s]);
     }
 
+    class TFinalLinkTraverser : public TIntermTraverser {
+    public:
+        TFinalLinkTraverser() { }
+        virtual ~TFinalLinkTraverser() { }
+
+        virtual void visitSymbol(TIntermSymbol* symbol)
+        {
+            // Implicitly size arrays.
+            // If an unsized array is left as unsized, it effectively
+            // becomes run-time sized.
+            symbol->getWritableType().adoptImplicitArraySizes(false);
+        }
+    } finalLinkTraverser;
+
     // no extra linking if there is only one stage
-    if (! (activeStages.size() > 1))
+    if (! (activeStages.size() > 1)) {
+        if (activeStages.size() == 1 && activeStages[0]->getTreeRoot()) {
+            activeStages[0]->getTreeRoot()->traverse(&finalLinkTraverser);
+        }
         return true;
+    }
 
     // setup temporary tree to hold unfirom objects from different stages
     TIntermediate* firstIntermediate = activeStages.front();
@@ -2081,6 +2117,12 @@ bool TProgram::crossStageCheck(EShMessages messages) {
     }
     error |= uniforms.getNumErrors() != 0;
 
+    // update implicit array sizes across shader stages
+    for (unsigned int i = 0; i < activeStages.size(); ++i) {
+        activeStages[i]->mergeImplicitArraySizes(*infoSink, uniforms);
+        activeStages[i]->getTreeRoot()->traverse(&finalLinkTraverser);
+    }
+
     // copy final definition of global block back into each stage
     for (unsigned int i = 0; i < activeStages.size(); ++i) {
         // We only want to merge into already existing global uniform blocks.
@@ -2093,8 +2135,15 @@ bool TProgram::crossStageCheck(EShMessages messages) {
 
     // compare cross stage symbols for each stage boundary
     for (unsigned int i = 1; i < activeStages.size(); ++i) {
-        activeStages[i - 1]->checkStageIO(messages, *infoSink, *activeStages[i]);
-        error |= (activeStages[i - 1]->getNumErrors() != 0);
+        activeStages[i - 1]->checkStageIO(*infoSink, *activeStages[i], messages);
+        error |= (activeStages[i - 1]->getNumErrors() != 0 || activeStages[i]->getNumErrors() != 0);
+    }
+
+    // if requested, optimize cross stage IO
+    if (messages & EShMsgLinkTimeOptimization) {
+        for (unsigned int i = 1; i < activeStages.size(); ++i) {
+            activeStages[i - 1]->optimizeStageIO(*infoSink, *activeStages[i]);
+        }
     }
 
     return !error;
@@ -2151,6 +2200,7 @@ bool TProgram::buildReflection(int opts)
 }
 
 unsigned TProgram::getLocalSize(int dim) const                        { return reflection->getLocalSize(dim); }
+unsigned TProgram::getTileShadingRateQCOM(int dim) const              { return reflection->getTileShadingRateQCOM(dim); }
 int TProgram::getReflectionIndex(const char* name) const              { return reflection->getIndex(name); }
 int TProgram::getReflectionPipeIOIndex(const char* name, const bool inOrOut) const
                                                                       { return reflection->getPipeIOIndex(name, inOrOut); }
@@ -2171,6 +2221,12 @@ int TProgram::getNumAtomicCounters() const                            { return r
 const TObjectReflection& TProgram::getAtomicCounter(int index) const  { return reflection->getAtomicCounter(index); }
 void TProgram::dumpReflection() { if (reflection != nullptr) reflection->dump(); }
 
+TIoMapResolver* TProgram::getGlslIoResolver(EShLanguage stage) {
+    auto *intermediate = getIntermediate(stage);
+    if (!intermediate)
+        return NULL;
+    return static_cast<TIoMapResolver*>(new TDefaultGlslIoResolver(*intermediate));
+}
 //
 // I/O mapping implementation.
 //

+ 27 - 1
src/libraries/glslang/glslang/MachineIndependent/SymbolTable.cpp

@@ -60,6 +60,9 @@ void TType::buildMangledName(TString& mangledName) const
     else if (isVector())
         mangledName += 'v';
 
+    if (isCoopVecNV())
+        mangledName += "coopvec";
+
     switch (basicType) {
     case EbtFloat:              mangledName += 'f';      break;
     case EbtInt:                mangledName += 'i';      break;
@@ -67,6 +70,9 @@ void TType::buildMangledName(TString& mangledName) const
     case EbtBool:               mangledName += 'b';      break;
     case EbtDouble:             mangledName += 'd';      break;
     case EbtFloat16:            mangledName += "f16";    break;
+    case EbtBFloat16:           mangledName += "bf16";   break;
+    case EbtFloatE5M2:          mangledName += "fe5m2";  break;
+    case EbtFloatE4M3:          mangledName += "fe4m3";  break;
     case EbtInt8:               mangledName += "i8";     break;
     case EbtUint8:              mangledName += "u8";     break;
     case EbtInt16:              mangledName += "i16";    break;
@@ -78,6 +84,8 @@ void TType::buildMangledName(TString& mangledName) const
     case EbtRayQuery:           mangledName += "rq";     break;
     case EbtSpirvType:          mangledName += "spv-t";  break;
     case EbtHitObjectNV:        mangledName += "ho";     break;
+    case EbtTensorLayoutNV:     mangledName += "tl";     break;
+    case EbtTensorViewNV:       mangledName += "tv";     break;
     case EbtSampler:
         switch (sampler.type) {
         case EbtFloat16: mangledName += "f16"; break;
@@ -161,6 +169,23 @@ void TType::buildMangledName(TString& mangledName) const
         mangledName += static_cast<char>('0' + getMatrixRows());
     }
 
+    if (typeParameters) {
+        const int maxSize = 11;
+        char buf[maxSize];
+        for (int i = 0; i < typeParameters->arraySizes->getNumDims(); ++i) {
+            if (typeParameters->arraySizes->getDimNode(i)) {
+                if (typeParameters->arraySizes->getDimNode(i)->getAsSymbolNode())
+                    snprintf(buf, maxSize, "s%lld", typeParameters->arraySizes->getDimNode(i)->getAsSymbolNode()->getId());
+                else
+                    snprintf(buf, maxSize, "s%p", typeParameters->arraySizes->getDimNode(i));
+            } else
+                snprintf(buf, maxSize, "%d", typeParameters->arraySizes->getDimSize(i));
+            mangledName += '<';
+            mangledName += buf;
+            mangledName += '>';
+        }
+    }
+
     if (arraySizes) {
         const int maxSize = 11;
         char buf[maxSize];
@@ -169,7 +194,7 @@ void TType::buildMangledName(TString& mangledName) const
                 if (arraySizes->getDimNode(i)->getAsSymbolNode())
                     snprintf(buf, maxSize, "s%lld", arraySizes->getDimNode(i)->getAsSymbolNode()->getId());
                 else
-                    snprintf(buf, maxSize, "s%p", arraySizes->getDimNode(i));
+                    snprintf(buf, maxSize, "s%p", (void*)(arraySizes->getDimNode(i)));
             } else
                 snprintf(buf, maxSize, "%d", arraySizes->getDimSize(i));
             mangledName += '[';
@@ -344,6 +369,7 @@ void TSymbolTableLevel::readOnly()
 TSymbol::TSymbol(const TSymbol& copyOf)
 {
     name = NewPoolTString(copyOf.name->c_str());
+    mangledName = NewPoolTString(copyOf.mangledName->c_str());
     uniqueId = copyOf.uniqueId;
     writable = true;
 }

+ 7 - 3
src/libraries/glslang/glslang/MachineIndependent/SymbolTable.h

@@ -84,7 +84,8 @@ typedef TVector<const char*> TExtensionList;
 class TSymbol {
 public:
     POOL_ALLOCATOR_NEW_DELETE(GetThreadPoolAllocator())
-    explicit TSymbol(const TString *n) :  name(n), uniqueId(0), extensions(nullptr), writable(true) { }
+    explicit TSymbol(const TString *n, const TString *mn) :  name(n), mangledName(mn), uniqueId(0), extensions(nullptr), writable(true) { }
+    explicit TSymbol(const TString *n) : TSymbol(n, n) { }
     virtual TSymbol* clone() const = 0;
     virtual ~TSymbol() { }  // rely on all symbol owned memory coming from the pool
 
@@ -96,7 +97,7 @@ public:
         newName.append(*name);
         changeName(NewPoolTString(newName.c_str()));
     }
-    virtual const TString& getMangledName() const { return getName(); }
+    virtual const TString& getMangledName() const { return *mangledName; }
     virtual TFunction* getAsFunction() { return nullptr; }
     virtual const TFunction* getAsFunction() const { return nullptr; }
     virtual TVariable* getAsVariable() { return nullptr; }
@@ -128,6 +129,7 @@ protected:
     TSymbol& operator=(const TSymbol&);
 
     const TString *name;
+    const TString *mangledName;
     unsigned long long uniqueId;      // For cross-scope comparing during code generation
 
     // For tracking what extensions must be present
@@ -154,7 +156,9 @@ protected:
 class TVariable : public TSymbol {
 public:
     TVariable(const TString *name, const TType& t, bool uT = false )
-        : TSymbol(name),
+        : TVariable(name, name, t, uT) {}
+    TVariable(const TString *name, const TString *mangledName, const TType& t, bool uT = false )
+        : TSymbol(name, mangledName),
           userType(uT),
           constSubtree(nullptr),
           memberExtensions(nullptr),

+ 117 - 11
src/libraries/glslang/glslang/MachineIndependent/Versions.cpp

@@ -165,7 +165,8 @@ void TParseVersions::initializeExtensionBehavior()
 
     const extensionData exts[] = { {E_GL_EXT_ray_tracing, EShTargetSpv_1_4},
                                    {E_GL_NV_ray_tracing_motion_blur, EShTargetSpv_1_4},
-                                   {E_GL_EXT_mesh_shader, EShTargetSpv_1_4}
+                                   {E_GL_EXT_mesh_shader, EShTargetSpv_1_4},
+                                   {E_GL_NV_cooperative_matrix2, EShTargetSpv_1_6}
                                  };
 
     for (size_t ii = 0; ii < sizeof(exts) / sizeof(exts[0]); ii++) {
@@ -187,7 +188,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_3DL_array_objects]                = EBhDisable;
     extensionBehavior[E_GL_ARB_shading_language_420pack]     = EBhDisable;
     extensionBehavior[E_GL_ARB_texture_gather]               = EBhDisable;
-    extensionBehavior[E_GL_ARB_gpu_shader5]                  = EBhDisablePartial;
+    extensionBehavior[E_GL_ARB_gpu_shader5]                  = EBhDisable;
     extensionBehavior[E_GL_ARB_separate_shader_objects]      = EBhDisable;
     extensionBehavior[E_GL_ARB_compute_shader]               = EBhDisable;
     extensionBehavior[E_GL_ARB_tessellation_shader]          = EBhDisable;
@@ -224,6 +225,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_ARB_shading_language_packing]     = EBhDisable;
     extensionBehavior[E_GL_ARB_texture_query_lod]            = EBhDisable;
     extensionBehavior[E_GL_ARB_vertex_attrib_64bit]          = EBhDisable;
+    extensionBehavior[E_GL_NV_gpu_shader5]                   = EBhDisable;
     extensionBehavior[E_GL_ARB_draw_instanced]               = EBhDisable;
     extensionBehavior[E_GL_ARB_bindless_texture]             = EBhDisable;
     extensionBehavior[E_GL_ARB_fragment_coord_conventions]   = EBhDisable;
@@ -268,6 +270,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_spec_constant_composites]                = EBhDisable;
 
     extensionBehavior[E_GL_KHR_cooperative_matrix]                      = EBhDisable;
+    extensionBehavior[E_GL_NV_cooperative_vector]                       = EBhDisable;
 
     // #line and #include
     extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive]          = EBhDisable;
@@ -310,6 +313,9 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_NV_shader_invocation_reorder]             = EBhDisable;
     extensionBehavior[E_GL_NV_displacement_micromap]                 = EBhDisable;
     extensionBehavior[E_GL_NV_shader_atomic_fp16_vector]             = EBhDisable;
+    extensionBehavior[E_GL_NV_cooperative_matrix2]                   = EBhDisable;
+    extensionBehavior[E_GL_NV_cluster_acceleration_structure]        = EBhDisable;
+    extensionBehavior[E_GL_NV_linear_swept_spheres]                  = EBhDisable;
 
     // ARM
     extensionBehavior[E_GL_ARM_shader_core_builtins]                 = EBhDisable;
@@ -317,6 +323,7 @@ void TParseVersions::initializeExtensionBehavior()
     // QCOM
     extensionBehavior[E_GL_QCOM_image_processing]                    = EBhDisable;
     extensionBehavior[E_GL_QCOM_image_processing2]                   = EBhDisable;
+    extensionBehavior[E_GL_QCOM_tile_shading]                        = EBhDisable;
 
     // AEP
     extensionBehavior[E_GL_ANDROID_extension_pack_es31a]             = EBhDisable;
@@ -371,6 +378,11 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_texture_shadow_lod]          = EBhDisable;
     extensionBehavior[E_GL_EXT_draw_instanced]              = EBhDisable;
     extensionBehavior[E_GL_EXT_texture_array]               = EBhDisable;
+    extensionBehavior[E_GL_EXT_texture_offset_non_const]    = EBhDisable;
+    extensionBehavior[E_GL_EXT_nontemporal_keyword]         = EBhDisable;
+    extensionBehavior[E_GL_EXT_bfloat16]                    = EBhDisable;
+    extensionBehavior[E_GL_EXT_float_e4m3]                  = EBhDisable;
+    extensionBehavior[E_GL_EXT_float_e5m2]                  = EBhDisable;
 
     // OVR extensions
     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
@@ -394,6 +406,8 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_shader_atomic_float]                    = EBhDisable;
     extensionBehavior[E_GL_EXT_shader_atomic_float2]                   = EBhDisable;
 
+    extensionBehavior[E_GL_EXT_integer_dot_product]                    = EBhDisable;
+
     // Record extensions not for spv.
     spvUnsupportedExt.push_back(E_GL_ARB_bindless_texture);
 }
@@ -449,6 +463,7 @@ void TParseVersions::getPreamble(std::string& preamble)
 
             "#define GL_QCOM_image_processing 1\n"
             "#define GL_QCOM_image_processing2 1\n"
+            "#define GL_QCOM_tile_shading 1\n"
             ;
 
             if (version >= 300) {
@@ -499,6 +514,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_ARB_shader_storage_buffer_object 1\n"
             "#define GL_ARB_texture_query_lod 1\n"
             "#define GL_ARB_vertex_attrib_64bit 1\n"
+            "#define GL_NV_gpu_shader5 1\n"
             "#define GL_ARB_draw_instanced 1\n"
             "#define GL_ARB_fragment_coord_conventions 1\n"
 
@@ -574,9 +590,11 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_NV_cooperative_matrix 1\n"
             "#define GL_NV_integer_cooperative_matrix 1\n"
             "#define GL_NV_shader_invocation_reorder 1\n"
+            "#define GL_NV_cooperative_matrix2 1\n"
 
             "#define GL_QCOM_image_processing 1\n"
             "#define GL_QCOM_image_processing2 1\n"
+            "#define GL_QCOM_tile_shading 1\n"
 
             "#define GL_EXT_shader_explicit_arithmetic_types 1\n"
             "#define GL_EXT_shader_explicit_arithmetic_types_int8 1\n"
@@ -600,6 +618,11 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_EXT_texture_array 1\n"
 
             "#define GL_EXT_control_flow_attributes2 1\n"
+
+            "#define GL_EXT_integer_dot_product 1\n"
+            "#define GL_EXT_bfloat16 1\n"
+            "#define GL_EXT_float_e5m2 1\n"
+            "#define GL_EXT_float_e4m3 1\n"
             ;
 
         if (spvVersion.spv == 0) {
@@ -632,6 +655,11 @@ void TParseVersions::getPreamble(std::string& preamble)
             ;
     }
 
+    if ((!isEsProfile() && version >= 130) ||
+        (isEsProfile() && version >= 300)) {
+        preamble += "#define GL_EXT_texture_offset_non_const 1\n";
+    }
+
     if (version >= 300 /* both ES and non-ES */) {
         preamble +=
             "#define GL_OVR_multiview 1\n"
@@ -1021,6 +1049,8 @@ void TParseVersions::updateExtensionBehavior(int line, const char* extension, co
         updateExtensionBehavior(line, "GL_EXT_buffer_reference", behaviorString);
     else if (strcmp(extension, "GL_NV_integer_cooperative_matrix") == 0)
         updateExtensionBehavior(line, "GL_NV_cooperative_matrix", behaviorString);
+    else if (strcmp(extension, "GL_NV_cooperative_matrix2") == 0)
+        updateExtensionBehavior(line, "GL_KHR_cooperative_matrix", behaviorString);
     // subgroup extended types to explicit types
     else if (strcmp(extension, "GL_EXT_shader_subgroup_extended_types_int8") == 0)
         updateExtensionBehavior(line, "GL_EXT_shader_explicit_arithmetic_types_int8", behaviorString);
@@ -1056,6 +1086,9 @@ void TParseVersions::updateExtensionBehavior(int line, const char* extension, co
         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_int16, on);
     else if (strcmp(extension, "GL_AMD_gpu_shader_half_float") == 0)
         intermediate.updateNumericFeature(TNumericFeatures::gpu_shader_half_float, on);
+    else if (strcmp(extension, "GL_NV_gpu_shader5") == 0) {
+        intermediate.updateNumericFeature(TNumericFeatures::nv_gpu_shader5_types, on);
+    }
 }
 
 void TParseVersions::updateExtensionBehavior(const char* extension, TExtensionBehavior behavior)
@@ -1183,6 +1216,7 @@ bool TParseVersions::float16Arithmetic()
     const char* const extensions[] = {
                                        E_GL_AMD_gpu_shader_half_float,
                                        E_GL_EXT_shader_explicit_arithmetic_types,
+                                       E_GL_NV_gpu_shader5,
                                        E_GL_EXT_shader_explicit_arithmetic_types_float16};
     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
 }
@@ -1192,6 +1226,7 @@ bool TParseVersions::int16Arithmetic()
     const char* const extensions[] = {
                                        E_GL_AMD_gpu_shader_int16,
                                        E_GL_EXT_shader_explicit_arithmetic_types,
+                                       E_GL_NV_gpu_shader5,
                                        E_GL_EXT_shader_explicit_arithmetic_types_int16};
     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
 }
@@ -1200,6 +1235,7 @@ bool TParseVersions::int8Arithmetic()
 {
     const char* const extensions[] = {
                                        E_GL_EXT_shader_explicit_arithmetic_types,
+                                       E_GL_NV_gpu_shader5,
                                        E_GL_EXT_shader_explicit_arithmetic_types_int8};
     return extensionsTurnedOn(sizeof(extensions)/sizeof(extensions[0]), extensions);
 }
@@ -1214,6 +1250,7 @@ void TParseVersions::requireFloat16Arithmetic(const TSourceLoc& loc, const char*
     const char* const extensions[] = {
                                        E_GL_AMD_gpu_shader_half_float,
                                        E_GL_EXT_shader_explicit_arithmetic_types,
+                                       E_GL_NV_gpu_shader5,
                                        E_GL_EXT_shader_explicit_arithmetic_types_float16};
     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
 }
@@ -1228,6 +1265,7 @@ void TParseVersions::requireInt16Arithmetic(const TSourceLoc& loc, const char* o
     const char* const extensions[] = {
                                        E_GL_AMD_gpu_shader_int16,
                                        E_GL_EXT_shader_explicit_arithmetic_types,
+                                       E_GL_NV_gpu_shader5,
                                        E_GL_EXT_shader_explicit_arithmetic_types_int16};
     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
 }
@@ -1241,6 +1279,7 @@ void TParseVersions::requireInt8Arithmetic(const TSourceLoc& loc, const char* op
 
     const char* const extensions[] = {
                                        E_GL_EXT_shader_explicit_arithmetic_types,
+                                       E_GL_NV_gpu_shader5,
                                        E_GL_EXT_shader_explicit_arithmetic_types_int8};
     requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, combined.c_str());
 }
@@ -1252,18 +1291,50 @@ void TParseVersions::float16ScalarVectorCheck(const TSourceLoc& loc, const char*
                                            E_GL_AMD_gpu_shader_half_float,
                                            E_GL_EXT_shader_16bit_storage,
                                            E_GL_EXT_shader_explicit_arithmetic_types,
+                                           E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_float16};
         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
     }
 }
 
+void TParseVersions::bfloat16ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {
+                                           E_GL_EXT_bfloat16,
+                                         };
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
+void TParseVersions::floate5m2ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {
+                                           E_GL_EXT_float_e5m2,
+                                         };
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
+void TParseVersions::floate4m3ScalarVectorCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {
+                                           E_GL_EXT_float_e4m3,
+                                         };
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
 // Call for any operation needing GLSL float32 data-type support.
 void TParseVersions::explicitFloat32Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (!builtIn) {
-        const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
+        const char* const extensions[] = {E_GL_EXT_shader_explicit_arithmetic_types,
+                                          E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_float32};
-        requireExtensions(loc, 2, extensions, op);
+        requireExtensions(loc, sizeof(extensions) / sizeof(extensions[0]), extensions, op);
     }
 }
 
@@ -1271,11 +1342,15 @@ void TParseVersions::explicitFloat32Check(const TSourceLoc& loc, const char* op,
 void TParseVersions::explicitFloat64Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (!builtIn) {
-        const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
+        const char* const extensions[] = {E_GL_EXT_shader_explicit_arithmetic_types,
+                                           E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_float64};
-        requireExtensions(loc, 2, extensions, op);
+        requireExtensions(loc, sizeof(extensions) / sizeof(extensions[0]), extensions, op);
         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
-        profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
+        if(extensionTurnedOn(E_GL_ARB_gpu_shader_fp64) && extensionTurnedOn(E_GL_NV_gpu_shader5))
+            profileRequires(loc, ECoreProfile | ECompatibilityProfile, 150, nullptr, op);
+        else
+            profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
     }
 }
 
@@ -1318,6 +1393,7 @@ void TParseVersions::int16ScalarVectorCheck(const TSourceLoc& loc, const char* o
                                            E_GL_AMD_gpu_shader_int16,
                                            E_GL_EXT_shader_16bit_storage,
                                            E_GL_EXT_shader_explicit_arithmetic_types,
+                                           E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_int16};
         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
     }
@@ -1329,6 +1405,7 @@ void TParseVersions::int8ScalarVectorCheck(const TSourceLoc& loc, const char* op
     	const char* const extensions[] = {
                                            E_GL_EXT_shader_8bit_storage,
                                            E_GL_EXT_shader_explicit_arithmetic_types,
+                                           E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_int8};
         requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
     }
@@ -1338,9 +1415,10 @@ void TParseVersions::int8ScalarVectorCheck(const TSourceLoc& loc, const char* op
 void TParseVersions::explicitInt32Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (! builtIn) {
-        const char* const extensions[2] = {E_GL_EXT_shader_explicit_arithmetic_types,
+        const char* const extensions[] = {E_GL_EXT_shader_explicit_arithmetic_types,
+                                           E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_int32};
-        requireExtensions(loc, 2, extensions, op);
+        requireExtensions(loc, sizeof(extensions) / sizeof(extensions[0]), extensions, op);
     }
 }
 
@@ -1348,11 +1426,15 @@ void TParseVersions::explicitInt32Check(const TSourceLoc& loc, const char* op, b
 void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (! builtIn) {
-        const char* const extensions[3] = {E_GL_ARB_gpu_shader_int64,
+        const char* const extensions[] = {E_GL_ARB_gpu_shader_int64,
                                            E_GL_EXT_shader_explicit_arithmetic_types,
+                                           E_GL_NV_gpu_shader5,
                                            E_GL_EXT_shader_explicit_arithmetic_types_int64};
-        requireExtensions(loc, 3, extensions, op);
+        requireExtensions(loc, sizeof(extensions) / sizeof(extensions[0]), extensions, op);
         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
+        if (extensionTurnedOn(E_GL_NV_gpu_shader5))
+            profileRequires(loc, ECoreProfile | ECompatibilityProfile, 150, nullptr, op);
+        else
         profileRequires(loc, ECoreProfile | ECompatibilityProfile, 400, nullptr, op);
     }
 }
@@ -1381,6 +1463,30 @@ void TParseVersions::coopmatCheck(const TSourceLoc& loc, const char* op, bool bu
     }
 }
 
+void TParseVersions::tensorLayoutViewCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {E_GL_NV_cooperative_matrix2};
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
+void TParseVersions::coopvecCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {E_GL_NV_cooperative_vector};
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
+void TParseVersions::intattachmentCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {E_GL_QCOM_tile_shading};
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
 // Call for any operation removed because SPIR-V is in use.
 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
 {

+ 18 - 0
src/libraries/glslang/glslang/MachineIndependent/Versions.h

@@ -4,6 +4,7 @@
 // Copyright (C) 2017, 2022-2024 Arm Limited.
 // Copyright (C) 2015-2018 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
+// Modifications Copyright (C) 2024 Valve Corporation.
 //
 // All rights reserved.
 //
@@ -223,6 +224,8 @@ const char* const E_GL_EXT_maximal_reconvergence            = "GL_EXT_maximal_re
 const char* const E_GL_EXT_expect_assume                    = "GL_EXT_expect_assume";
 const char* const E_GL_EXT_control_flow_attributes2         = "GL_EXT_control_flow_attributes2";
 const char* const E_GL_EXT_spec_constant_composites         = "GL_EXT_spec_constant_composites";
+const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_offset_non_const";
+const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
 
 // Arrays of extensions for the above viewportEXTs duplications
 
@@ -282,6 +285,11 @@ const char* const E_GL_NV_shader_invocation_reorder             = "GL_NV_shader_
 const char* const E_GL_EXT_ray_tracing_position_fetch           = "GL_EXT_ray_tracing_position_fetch";
 const char* const E_GL_NV_displacement_micromap                 = "GL_NV_displacement_micromap";
 const char* const E_GL_NV_shader_atomic_fp16_vector             = "GL_NV_shader_atomic_fp16_vector";
+const char* const E_GL_NV_cooperative_matrix2                   = "GL_NV_cooperative_matrix2";
+const char* const E_GL_NV_cooperative_vector                    = "GL_NV_cooperative_vector";
+const char* const E_GL_NV_cluster_acceleration_structure        = "GL_NV_cluster_acceleration_structure";
+const char* const E_GL_NV_linear_swept_spheres                  = "GL_NV_linear_swept_spheres";
+const char* const E_GL_NV_gpu_shader5                           = "GL_NV_gpu_shader5";
 
 // ARM
 const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
@@ -294,6 +302,7 @@ const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
 
 const char* const E_GL_QCOM_image_processing                    = "GL_QCOM_image_processing";
 const char* const E_GL_QCOM_image_processing2                   = "GL_QCOM_image_processing2";
+const char* const E_GL_QCOM_tile_shading                        = "GL_QCOM_tile_shading";
 
 // AEP
 const char* const E_GL_ANDROID_extension_pack_es31a             = "GL_ANDROID_extension_pack_es31a";
@@ -347,6 +356,12 @@ const char* const E_GL_EXT_shader_tile_image = "GL_EXT_shader_tile_image";
 
 const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod";
 
+const char* const E_GL_EXT_integer_dot_product                    = "GL_EXT_integer_dot_product";
+
+const char* const E_GL_EXT_bfloat16 = "GL_EXT_bfloat16";
+const char* const E_GL_EXT_float_e5m2 = "GL_EXT_float_e5m2";
+const char* const E_GL_EXT_float_e4m3 = "GL_EXT_float_e4m3";
+
 // Arrays of extensions for the above AEP duplications
 
 const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader };
@@ -358,6 +373,9 @@ const int Num_AEP_geometry_point_size = sizeof(AEP_geometry_point_size)/sizeof(A
 const char* const AEP_gpu_shader5[] = { E_GL_EXT_gpu_shader5, E_GL_OES_gpu_shader5 };
 const int Num_AEP_gpu_shader5 = sizeof(AEP_gpu_shader5)/sizeof(AEP_gpu_shader5[0]);
 
+const char* const AEP_core_gpu_shader5[] = { E_GL_ARB_gpu_shader5, E_GL_NV_gpu_shader5};
+const int Num_AEP_core_gpu_shader5 = sizeof(AEP_core_gpu_shader5)/sizeof(AEP_core_gpu_shader5[0]);
+
 const char* const AEP_primitive_bounding_box[] = { E_GL_EXT_primitive_bounding_box, E_GL_OES_primitive_bounding_box };
 const int Num_AEP_primitive_bounding_box = sizeof(AEP_primitive_bounding_box)/sizeof(AEP_primitive_bounding_box[0]);
 

文件差异内容过多而无法显示
+ 551 - 534
src/libraries/glslang/glslang/MachineIndependent/glslang_tab.cpp


+ 420 - 403
src/libraries/glslang/glslang/MachineIndependent/glslang_tab.cpp.h

@@ -114,408 +114,425 @@ extern int yydebug;
     UTEXTURE2DARRAY = 315,         /* UTEXTURE2DARRAY  */
     ATTRIBUTE = 316,               /* ATTRIBUTE  */
     VARYING = 317,                 /* VARYING  */
-    FLOAT16_T = 318,               /* FLOAT16_T  */
-    FLOAT32_T = 319,               /* FLOAT32_T  */
-    DOUBLE = 320,                  /* DOUBLE  */
-    FLOAT64_T = 321,               /* FLOAT64_T  */
-    INT64_T = 322,                 /* INT64_T  */
-    UINT64_T = 323,                /* UINT64_T  */
-    INT32_T = 324,                 /* INT32_T  */
-    UINT32_T = 325,                /* UINT32_T  */
-    INT16_T = 326,                 /* INT16_T  */
-    UINT16_T = 327,                /* UINT16_T  */
-    INT8_T = 328,                  /* INT8_T  */
-    UINT8_T = 329,                 /* UINT8_T  */
-    I64VEC2 = 330,                 /* I64VEC2  */
-    I64VEC3 = 331,                 /* I64VEC3  */
-    I64VEC4 = 332,                 /* I64VEC4  */
-    U64VEC2 = 333,                 /* U64VEC2  */
-    U64VEC3 = 334,                 /* U64VEC3  */
-    U64VEC4 = 335,                 /* U64VEC4  */
-    I32VEC2 = 336,                 /* I32VEC2  */
-    I32VEC3 = 337,                 /* I32VEC3  */
-    I32VEC4 = 338,                 /* I32VEC4  */
-    U32VEC2 = 339,                 /* U32VEC2  */
-    U32VEC3 = 340,                 /* U32VEC3  */
-    U32VEC4 = 341,                 /* U32VEC4  */
-    I16VEC2 = 342,                 /* I16VEC2  */
-    I16VEC3 = 343,                 /* I16VEC3  */
-    I16VEC4 = 344,                 /* I16VEC4  */
-    U16VEC2 = 345,                 /* U16VEC2  */
-    U16VEC3 = 346,                 /* U16VEC3  */
-    U16VEC4 = 347,                 /* U16VEC4  */
-    I8VEC2 = 348,                  /* I8VEC2  */
-    I8VEC3 = 349,                  /* I8VEC3  */
-    I8VEC4 = 350,                  /* I8VEC4  */
-    U8VEC2 = 351,                  /* U8VEC2  */
-    U8VEC3 = 352,                  /* U8VEC3  */
-    U8VEC4 = 353,                  /* U8VEC4  */
-    DVEC2 = 354,                   /* DVEC2  */
-    DVEC3 = 355,                   /* DVEC3  */
-    DVEC4 = 356,                   /* DVEC4  */
-    DMAT2 = 357,                   /* DMAT2  */
-    DMAT3 = 358,                   /* DMAT3  */
-    DMAT4 = 359,                   /* DMAT4  */
-    F16VEC2 = 360,                 /* F16VEC2  */
-    F16VEC3 = 361,                 /* F16VEC3  */
-    F16VEC4 = 362,                 /* F16VEC4  */
-    F16MAT2 = 363,                 /* F16MAT2  */
-    F16MAT3 = 364,                 /* F16MAT3  */
-    F16MAT4 = 365,                 /* F16MAT4  */
-    F32VEC2 = 366,                 /* F32VEC2  */
-    F32VEC3 = 367,                 /* F32VEC3  */
-    F32VEC4 = 368,                 /* F32VEC4  */
-    F32MAT2 = 369,                 /* F32MAT2  */
-    F32MAT3 = 370,                 /* F32MAT3  */
-    F32MAT4 = 371,                 /* F32MAT4  */
-    F64VEC2 = 372,                 /* F64VEC2  */
-    F64VEC3 = 373,                 /* F64VEC3  */
-    F64VEC4 = 374,                 /* F64VEC4  */
-    F64MAT2 = 375,                 /* F64MAT2  */
-    F64MAT3 = 376,                 /* F64MAT3  */
-    F64MAT4 = 377,                 /* F64MAT4  */
-    DMAT2X2 = 378,                 /* DMAT2X2  */
-    DMAT2X3 = 379,                 /* DMAT2X3  */
-    DMAT2X4 = 380,                 /* DMAT2X4  */
-    DMAT3X2 = 381,                 /* DMAT3X2  */
-    DMAT3X3 = 382,                 /* DMAT3X3  */
-    DMAT3X4 = 383,                 /* DMAT3X4  */
-    DMAT4X2 = 384,                 /* DMAT4X2  */
-    DMAT4X3 = 385,                 /* DMAT4X3  */
-    DMAT4X4 = 386,                 /* DMAT4X4  */
-    F16MAT2X2 = 387,               /* F16MAT2X2  */
-    F16MAT2X3 = 388,               /* F16MAT2X3  */
-    F16MAT2X4 = 389,               /* F16MAT2X4  */
-    F16MAT3X2 = 390,               /* F16MAT3X2  */
-    F16MAT3X3 = 391,               /* F16MAT3X3  */
-    F16MAT3X4 = 392,               /* F16MAT3X4  */
-    F16MAT4X2 = 393,               /* F16MAT4X2  */
-    F16MAT4X3 = 394,               /* F16MAT4X3  */
-    F16MAT4X4 = 395,               /* F16MAT4X4  */
-    F32MAT2X2 = 396,               /* F32MAT2X2  */
-    F32MAT2X3 = 397,               /* F32MAT2X3  */
-    F32MAT2X4 = 398,               /* F32MAT2X4  */
-    F32MAT3X2 = 399,               /* F32MAT3X2  */
-    F32MAT3X3 = 400,               /* F32MAT3X3  */
-    F32MAT3X4 = 401,               /* F32MAT3X4  */
-    F32MAT4X2 = 402,               /* F32MAT4X2  */
-    F32MAT4X3 = 403,               /* F32MAT4X3  */
-    F32MAT4X4 = 404,               /* F32MAT4X4  */
-    F64MAT2X2 = 405,               /* F64MAT2X2  */
-    F64MAT2X3 = 406,               /* F64MAT2X3  */
-    F64MAT2X4 = 407,               /* F64MAT2X4  */
-    F64MAT3X2 = 408,               /* F64MAT3X2  */
-    F64MAT3X3 = 409,               /* F64MAT3X3  */
-    F64MAT3X4 = 410,               /* F64MAT3X4  */
-    F64MAT4X2 = 411,               /* F64MAT4X2  */
-    F64MAT4X3 = 412,               /* F64MAT4X3  */
-    F64MAT4X4 = 413,               /* F64MAT4X4  */
-    ATOMIC_UINT = 414,             /* ATOMIC_UINT  */
-    ACCSTRUCTNV = 415,             /* ACCSTRUCTNV  */
-    ACCSTRUCTEXT = 416,            /* ACCSTRUCTEXT  */
-    RAYQUERYEXT = 417,             /* RAYQUERYEXT  */
-    FCOOPMATNV = 418,              /* FCOOPMATNV  */
-    ICOOPMATNV = 419,              /* ICOOPMATNV  */
-    UCOOPMATNV = 420,              /* UCOOPMATNV  */
-    COOPMAT = 421,                 /* COOPMAT  */
-    HITOBJECTNV = 422,             /* HITOBJECTNV  */
-    HITOBJECTATTRNV = 423,         /* HITOBJECTATTRNV  */
-    SAMPLERCUBEARRAY = 424,        /* SAMPLERCUBEARRAY  */
-    SAMPLERCUBEARRAYSHADOW = 425,  /* SAMPLERCUBEARRAYSHADOW  */
-    ISAMPLERCUBEARRAY = 426,       /* ISAMPLERCUBEARRAY  */
-    USAMPLERCUBEARRAY = 427,       /* USAMPLERCUBEARRAY  */
-    SAMPLER1D = 428,               /* SAMPLER1D  */
-    SAMPLER1DARRAY = 429,          /* SAMPLER1DARRAY  */
-    SAMPLER1DARRAYSHADOW = 430,    /* SAMPLER1DARRAYSHADOW  */
-    ISAMPLER1D = 431,              /* ISAMPLER1D  */
-    SAMPLER1DSHADOW = 432,         /* SAMPLER1DSHADOW  */
-    SAMPLER2DRECT = 433,           /* SAMPLER2DRECT  */
-    SAMPLER2DRECTSHADOW = 434,     /* SAMPLER2DRECTSHADOW  */
-    ISAMPLER2DRECT = 435,          /* ISAMPLER2DRECT  */
-    USAMPLER2DRECT = 436,          /* USAMPLER2DRECT  */
-    SAMPLERBUFFER = 437,           /* SAMPLERBUFFER  */
-    ISAMPLERBUFFER = 438,          /* ISAMPLERBUFFER  */
-    USAMPLERBUFFER = 439,          /* USAMPLERBUFFER  */
-    SAMPLER2DMS = 440,             /* SAMPLER2DMS  */
-    ISAMPLER2DMS = 441,            /* ISAMPLER2DMS  */
-    USAMPLER2DMS = 442,            /* USAMPLER2DMS  */
-    SAMPLER2DMSARRAY = 443,        /* SAMPLER2DMSARRAY  */
-    ISAMPLER2DMSARRAY = 444,       /* ISAMPLER2DMSARRAY  */
-    USAMPLER2DMSARRAY = 445,       /* USAMPLER2DMSARRAY  */
-    SAMPLEREXTERNALOES = 446,      /* SAMPLEREXTERNALOES  */
-    SAMPLEREXTERNAL2DY2YEXT = 447, /* SAMPLEREXTERNAL2DY2YEXT  */
-    ISAMPLER1DARRAY = 448,         /* ISAMPLER1DARRAY  */
-    USAMPLER1D = 449,              /* USAMPLER1D  */
-    USAMPLER1DARRAY = 450,         /* USAMPLER1DARRAY  */
-    F16SAMPLER1D = 451,            /* F16SAMPLER1D  */
-    F16SAMPLER2D = 452,            /* F16SAMPLER2D  */
-    F16SAMPLER3D = 453,            /* F16SAMPLER3D  */
-    F16SAMPLER2DRECT = 454,        /* F16SAMPLER2DRECT  */
-    F16SAMPLERCUBE = 455,          /* F16SAMPLERCUBE  */
-    F16SAMPLER1DARRAY = 456,       /* F16SAMPLER1DARRAY  */
-    F16SAMPLER2DARRAY = 457,       /* F16SAMPLER2DARRAY  */
-    F16SAMPLERCUBEARRAY = 458,     /* F16SAMPLERCUBEARRAY  */
-    F16SAMPLERBUFFER = 459,        /* F16SAMPLERBUFFER  */
-    F16SAMPLER2DMS = 460,          /* F16SAMPLER2DMS  */
-    F16SAMPLER2DMSARRAY = 461,     /* F16SAMPLER2DMSARRAY  */
-    F16SAMPLER1DSHADOW = 462,      /* F16SAMPLER1DSHADOW  */
-    F16SAMPLER2DSHADOW = 463,      /* F16SAMPLER2DSHADOW  */
-    F16SAMPLER1DARRAYSHADOW = 464, /* F16SAMPLER1DARRAYSHADOW  */
-    F16SAMPLER2DARRAYSHADOW = 465, /* F16SAMPLER2DARRAYSHADOW  */
-    F16SAMPLER2DRECTSHADOW = 466,  /* F16SAMPLER2DRECTSHADOW  */
-    F16SAMPLERCUBESHADOW = 467,    /* F16SAMPLERCUBESHADOW  */
-    F16SAMPLERCUBEARRAYSHADOW = 468, /* F16SAMPLERCUBEARRAYSHADOW  */
-    IMAGE1D = 469,                 /* IMAGE1D  */
-    IIMAGE1D = 470,                /* IIMAGE1D  */
-    UIMAGE1D = 471,                /* UIMAGE1D  */
-    IMAGE2D = 472,                 /* IMAGE2D  */
-    IIMAGE2D = 473,                /* IIMAGE2D  */
-    UIMAGE2D = 474,                /* UIMAGE2D  */
-    IMAGE3D = 475,                 /* IMAGE3D  */
-    IIMAGE3D = 476,                /* IIMAGE3D  */
-    UIMAGE3D = 477,                /* UIMAGE3D  */
-    IMAGE2DRECT = 478,             /* IMAGE2DRECT  */
-    IIMAGE2DRECT = 479,            /* IIMAGE2DRECT  */
-    UIMAGE2DRECT = 480,            /* UIMAGE2DRECT  */
-    IMAGECUBE = 481,               /* IMAGECUBE  */
-    IIMAGECUBE = 482,              /* IIMAGECUBE  */
-    UIMAGECUBE = 483,              /* UIMAGECUBE  */
-    IMAGEBUFFER = 484,             /* IMAGEBUFFER  */
-    IIMAGEBUFFER = 485,            /* IIMAGEBUFFER  */
-    UIMAGEBUFFER = 486,            /* UIMAGEBUFFER  */
-    IMAGE1DARRAY = 487,            /* IMAGE1DARRAY  */
-    IIMAGE1DARRAY = 488,           /* IIMAGE1DARRAY  */
-    UIMAGE1DARRAY = 489,           /* UIMAGE1DARRAY  */
-    IMAGE2DARRAY = 490,            /* IMAGE2DARRAY  */
-    IIMAGE2DARRAY = 491,           /* IIMAGE2DARRAY  */
-    UIMAGE2DARRAY = 492,           /* UIMAGE2DARRAY  */
-    IMAGECUBEARRAY = 493,          /* IMAGECUBEARRAY  */
-    IIMAGECUBEARRAY = 494,         /* IIMAGECUBEARRAY  */
-    UIMAGECUBEARRAY = 495,         /* UIMAGECUBEARRAY  */
-    IMAGE2DMS = 496,               /* IMAGE2DMS  */
-    IIMAGE2DMS = 497,              /* IIMAGE2DMS  */
-    UIMAGE2DMS = 498,              /* UIMAGE2DMS  */
-    IMAGE2DMSARRAY = 499,          /* IMAGE2DMSARRAY  */
-    IIMAGE2DMSARRAY = 500,         /* IIMAGE2DMSARRAY  */
-    UIMAGE2DMSARRAY = 501,         /* UIMAGE2DMSARRAY  */
-    F16IMAGE1D = 502,              /* F16IMAGE1D  */
-    F16IMAGE2D = 503,              /* F16IMAGE2D  */
-    F16IMAGE3D = 504,              /* F16IMAGE3D  */
-    F16IMAGE2DRECT = 505,          /* F16IMAGE2DRECT  */
-    F16IMAGECUBE = 506,            /* F16IMAGECUBE  */
-    F16IMAGE1DARRAY = 507,         /* F16IMAGE1DARRAY  */
-    F16IMAGE2DARRAY = 508,         /* F16IMAGE2DARRAY  */
-    F16IMAGECUBEARRAY = 509,       /* F16IMAGECUBEARRAY  */
-    F16IMAGEBUFFER = 510,          /* F16IMAGEBUFFER  */
-    F16IMAGE2DMS = 511,            /* F16IMAGE2DMS  */
-    F16IMAGE2DMSARRAY = 512,       /* F16IMAGE2DMSARRAY  */
-    I64IMAGE1D = 513,              /* I64IMAGE1D  */
-    U64IMAGE1D = 514,              /* U64IMAGE1D  */
-    I64IMAGE2D = 515,              /* I64IMAGE2D  */
-    U64IMAGE2D = 516,              /* U64IMAGE2D  */
-    I64IMAGE3D = 517,              /* I64IMAGE3D  */
-    U64IMAGE3D = 518,              /* U64IMAGE3D  */
-    I64IMAGE2DRECT = 519,          /* I64IMAGE2DRECT  */
-    U64IMAGE2DRECT = 520,          /* U64IMAGE2DRECT  */
-    I64IMAGECUBE = 521,            /* I64IMAGECUBE  */
-    U64IMAGECUBE = 522,            /* U64IMAGECUBE  */
-    I64IMAGEBUFFER = 523,          /* I64IMAGEBUFFER  */
-    U64IMAGEBUFFER = 524,          /* U64IMAGEBUFFER  */
-    I64IMAGE1DARRAY = 525,         /* I64IMAGE1DARRAY  */
-    U64IMAGE1DARRAY = 526,         /* U64IMAGE1DARRAY  */
-    I64IMAGE2DARRAY = 527,         /* I64IMAGE2DARRAY  */
-    U64IMAGE2DARRAY = 528,         /* U64IMAGE2DARRAY  */
-    I64IMAGECUBEARRAY = 529,       /* I64IMAGECUBEARRAY  */
-    U64IMAGECUBEARRAY = 530,       /* U64IMAGECUBEARRAY  */
-    I64IMAGE2DMS = 531,            /* I64IMAGE2DMS  */
-    U64IMAGE2DMS = 532,            /* U64IMAGE2DMS  */
-    I64IMAGE2DMSARRAY = 533,       /* I64IMAGE2DMSARRAY  */
-    U64IMAGE2DMSARRAY = 534,       /* U64IMAGE2DMSARRAY  */
-    TEXTURECUBEARRAY = 535,        /* TEXTURECUBEARRAY  */
-    ITEXTURECUBEARRAY = 536,       /* ITEXTURECUBEARRAY  */
-    UTEXTURECUBEARRAY = 537,       /* UTEXTURECUBEARRAY  */
-    TEXTURE1D = 538,               /* TEXTURE1D  */
-    ITEXTURE1D = 539,              /* ITEXTURE1D  */
-    UTEXTURE1D = 540,              /* UTEXTURE1D  */
-    TEXTURE1DARRAY = 541,          /* TEXTURE1DARRAY  */
-    ITEXTURE1DARRAY = 542,         /* ITEXTURE1DARRAY  */
-    UTEXTURE1DARRAY = 543,         /* UTEXTURE1DARRAY  */
-    TEXTURE2DRECT = 544,           /* TEXTURE2DRECT  */
-    ITEXTURE2DRECT = 545,          /* ITEXTURE2DRECT  */
-    UTEXTURE2DRECT = 546,          /* UTEXTURE2DRECT  */
-    TEXTUREBUFFER = 547,           /* TEXTUREBUFFER  */
-    ITEXTUREBUFFER = 548,          /* ITEXTUREBUFFER  */
-    UTEXTUREBUFFER = 549,          /* UTEXTUREBUFFER  */
-    TEXTURE2DMS = 550,             /* TEXTURE2DMS  */
-    ITEXTURE2DMS = 551,            /* ITEXTURE2DMS  */
-    UTEXTURE2DMS = 552,            /* UTEXTURE2DMS  */
-    TEXTURE2DMSARRAY = 553,        /* TEXTURE2DMSARRAY  */
-    ITEXTURE2DMSARRAY = 554,       /* ITEXTURE2DMSARRAY  */
-    UTEXTURE2DMSARRAY = 555,       /* UTEXTURE2DMSARRAY  */
-    F16TEXTURE1D = 556,            /* F16TEXTURE1D  */
-    F16TEXTURE2D = 557,            /* F16TEXTURE2D  */
-    F16TEXTURE3D = 558,            /* F16TEXTURE3D  */
-    F16TEXTURE2DRECT = 559,        /* F16TEXTURE2DRECT  */
-    F16TEXTURECUBE = 560,          /* F16TEXTURECUBE  */
-    F16TEXTURE1DARRAY = 561,       /* F16TEXTURE1DARRAY  */
-    F16TEXTURE2DARRAY = 562,       /* F16TEXTURE2DARRAY  */
-    F16TEXTURECUBEARRAY = 563,     /* F16TEXTURECUBEARRAY  */
-    F16TEXTUREBUFFER = 564,        /* F16TEXTUREBUFFER  */
-    F16TEXTURE2DMS = 565,          /* F16TEXTURE2DMS  */
-    F16TEXTURE2DMSARRAY = 566,     /* F16TEXTURE2DMSARRAY  */
-    SUBPASSINPUT = 567,            /* SUBPASSINPUT  */
-    SUBPASSINPUTMS = 568,          /* SUBPASSINPUTMS  */
-    ISUBPASSINPUT = 569,           /* ISUBPASSINPUT  */
-    ISUBPASSINPUTMS = 570,         /* ISUBPASSINPUTMS  */
-    USUBPASSINPUT = 571,           /* USUBPASSINPUT  */
-    USUBPASSINPUTMS = 572,         /* USUBPASSINPUTMS  */
-    F16SUBPASSINPUT = 573,         /* F16SUBPASSINPUT  */
-    F16SUBPASSINPUTMS = 574,       /* F16SUBPASSINPUTMS  */
-    SPIRV_INSTRUCTION = 575,       /* SPIRV_INSTRUCTION  */
-    SPIRV_EXECUTION_MODE = 576,    /* SPIRV_EXECUTION_MODE  */
-    SPIRV_EXECUTION_MODE_ID = 577, /* SPIRV_EXECUTION_MODE_ID  */
-    SPIRV_DECORATE = 578,          /* SPIRV_DECORATE  */
-    SPIRV_DECORATE_ID = 579,       /* SPIRV_DECORATE_ID  */
-    SPIRV_DECORATE_STRING = 580,   /* SPIRV_DECORATE_STRING  */
-    SPIRV_TYPE = 581,              /* SPIRV_TYPE  */
-    SPIRV_STORAGE_CLASS = 582,     /* SPIRV_STORAGE_CLASS  */
-    SPIRV_BY_REFERENCE = 583,      /* SPIRV_BY_REFERENCE  */
-    SPIRV_LITERAL = 584,           /* SPIRV_LITERAL  */
-    ATTACHMENTEXT = 585,           /* ATTACHMENTEXT  */
-    IATTACHMENTEXT = 586,          /* IATTACHMENTEXT  */
-    UATTACHMENTEXT = 587,          /* UATTACHMENTEXT  */
-    LEFT_OP = 588,                 /* LEFT_OP  */
-    RIGHT_OP = 589,                /* RIGHT_OP  */
-    INC_OP = 590,                  /* INC_OP  */
-    DEC_OP = 591,                  /* DEC_OP  */
-    LE_OP = 592,                   /* LE_OP  */
-    GE_OP = 593,                   /* GE_OP  */
-    EQ_OP = 594,                   /* EQ_OP  */
-    NE_OP = 595,                   /* NE_OP  */
-    AND_OP = 596,                  /* AND_OP  */
-    OR_OP = 597,                   /* OR_OP  */
-    XOR_OP = 598,                  /* XOR_OP  */
-    MUL_ASSIGN = 599,              /* MUL_ASSIGN  */
-    DIV_ASSIGN = 600,              /* DIV_ASSIGN  */
-    ADD_ASSIGN = 601,              /* ADD_ASSIGN  */
-    MOD_ASSIGN = 602,              /* MOD_ASSIGN  */
-    LEFT_ASSIGN = 603,             /* LEFT_ASSIGN  */
-    RIGHT_ASSIGN = 604,            /* RIGHT_ASSIGN  */
-    AND_ASSIGN = 605,              /* AND_ASSIGN  */
-    XOR_ASSIGN = 606,              /* XOR_ASSIGN  */
-    OR_ASSIGN = 607,               /* OR_ASSIGN  */
-    SUB_ASSIGN = 608,              /* SUB_ASSIGN  */
-    STRING_LITERAL = 609,          /* STRING_LITERAL  */
-    LEFT_PAREN = 610,              /* LEFT_PAREN  */
-    RIGHT_PAREN = 611,             /* RIGHT_PAREN  */
-    LEFT_BRACKET = 612,            /* LEFT_BRACKET  */
-    RIGHT_BRACKET = 613,           /* RIGHT_BRACKET  */
-    LEFT_BRACE = 614,              /* LEFT_BRACE  */
-    RIGHT_BRACE = 615,             /* RIGHT_BRACE  */
-    DOT = 616,                     /* DOT  */
-    COMMA = 617,                   /* COMMA  */
-    COLON = 618,                   /* COLON  */
-    EQUAL = 619,                   /* EQUAL  */
-    SEMICOLON = 620,               /* SEMICOLON  */
-    BANG = 621,                    /* BANG  */
-    DASH = 622,                    /* DASH  */
-    TILDE = 623,                   /* TILDE  */
-    PLUS = 624,                    /* PLUS  */
-    STAR = 625,                    /* STAR  */
-    SLASH = 626,                   /* SLASH  */
-    PERCENT = 627,                 /* PERCENT  */
-    LEFT_ANGLE = 628,              /* LEFT_ANGLE  */
-    RIGHT_ANGLE = 629,             /* RIGHT_ANGLE  */
-    VERTICAL_BAR = 630,            /* VERTICAL_BAR  */
-    CARET = 631,                   /* CARET  */
-    AMPERSAND = 632,               /* AMPERSAND  */
-    QUESTION = 633,                /* QUESTION  */
-    INVARIANT = 634,               /* INVARIANT  */
-    HIGH_PRECISION = 635,          /* HIGH_PRECISION  */
-    MEDIUM_PRECISION = 636,        /* MEDIUM_PRECISION  */
-    LOW_PRECISION = 637,           /* LOW_PRECISION  */
-    PRECISION = 638,               /* PRECISION  */
-    PACKED = 639,                  /* PACKED  */
-    RESOURCE = 640,                /* RESOURCE  */
-    SUPERP = 641,                  /* SUPERP  */
-    FLOATCONSTANT = 642,           /* FLOATCONSTANT  */
-    INTCONSTANT = 643,             /* INTCONSTANT  */
-    UINTCONSTANT = 644,            /* UINTCONSTANT  */
-    BOOLCONSTANT = 645,            /* BOOLCONSTANT  */
-    IDENTIFIER = 646,              /* IDENTIFIER  */
-    TYPE_NAME = 647,               /* TYPE_NAME  */
-    CENTROID = 648,                /* CENTROID  */
-    IN = 649,                      /* IN  */
-    OUT = 650,                     /* OUT  */
-    INOUT = 651,                   /* INOUT  */
-    STRUCT = 652,                  /* STRUCT  */
-    VOID = 653,                    /* VOID  */
-    WHILE = 654,                   /* WHILE  */
-    BREAK = 655,                   /* BREAK  */
-    CONTINUE = 656,                /* CONTINUE  */
-    DO = 657,                      /* DO  */
-    ELSE = 658,                    /* ELSE  */
-    FOR = 659,                     /* FOR  */
-    IF = 660,                      /* IF  */
-    DISCARD = 661,                 /* DISCARD  */
-    RETURN = 662,                  /* RETURN  */
-    SWITCH = 663,                  /* SWITCH  */
-    CASE = 664,                    /* CASE  */
-    DEFAULT = 665,                 /* DEFAULT  */
-    TERMINATE_INVOCATION = 666,    /* TERMINATE_INVOCATION  */
-    TERMINATE_RAY = 667,           /* TERMINATE_RAY  */
-    IGNORE_INTERSECTION = 668,     /* IGNORE_INTERSECTION  */
-    UNIFORM = 669,                 /* UNIFORM  */
-    SHARED = 670,                  /* SHARED  */
-    BUFFER = 671,                  /* BUFFER  */
-    TILEIMAGEEXT = 672,            /* TILEIMAGEEXT  */
-    FLAT = 673,                    /* FLAT  */
-    SMOOTH = 674,                  /* SMOOTH  */
-    LAYOUT = 675,                  /* LAYOUT  */
-    DOUBLECONSTANT = 676,          /* DOUBLECONSTANT  */
-    INT16CONSTANT = 677,           /* INT16CONSTANT  */
-    UINT16CONSTANT = 678,          /* UINT16CONSTANT  */
-    FLOAT16CONSTANT = 679,         /* FLOAT16CONSTANT  */
-    INT32CONSTANT = 680,           /* INT32CONSTANT  */
-    UINT32CONSTANT = 681,          /* UINT32CONSTANT  */
-    INT64CONSTANT = 682,           /* INT64CONSTANT  */
-    UINT64CONSTANT = 683,          /* UINT64CONSTANT  */
-    SUBROUTINE = 684,              /* SUBROUTINE  */
-    DEMOTE = 685,                  /* DEMOTE  */
-    PAYLOADNV = 686,               /* PAYLOADNV  */
-    PAYLOADINNV = 687,             /* PAYLOADINNV  */
-    HITATTRNV = 688,               /* HITATTRNV  */
-    CALLDATANV = 689,              /* CALLDATANV  */
-    CALLDATAINNV = 690,            /* CALLDATAINNV  */
-    PAYLOADEXT = 691,              /* PAYLOADEXT  */
-    PAYLOADINEXT = 692,            /* PAYLOADINEXT  */
-    HITATTREXT = 693,              /* HITATTREXT  */
-    CALLDATAEXT = 694,             /* CALLDATAEXT  */
-    CALLDATAINEXT = 695,           /* CALLDATAINEXT  */
-    PATCH = 696,                   /* PATCH  */
-    SAMPLE = 697,                  /* SAMPLE  */
-    NONUNIFORM = 698,              /* NONUNIFORM  */
-    COHERENT = 699,                /* COHERENT  */
-    VOLATILE = 700,                /* VOLATILE  */
-    RESTRICT = 701,                /* RESTRICT  */
-    READONLY = 702,                /* READONLY  */
-    WRITEONLY = 703,               /* WRITEONLY  */
-    DEVICECOHERENT = 704,          /* DEVICECOHERENT  */
-    QUEUEFAMILYCOHERENT = 705,     /* QUEUEFAMILYCOHERENT  */
-    WORKGROUPCOHERENT = 706,       /* WORKGROUPCOHERENT  */
-    SUBGROUPCOHERENT = 707,        /* SUBGROUPCOHERENT  */
-    NONPRIVATE = 708,              /* NONPRIVATE  */
-    SHADERCALLCOHERENT = 709,      /* SHADERCALLCOHERENT  */
-    NOPERSPECTIVE = 710,           /* NOPERSPECTIVE  */
-    EXPLICITINTERPAMD = 711,       /* EXPLICITINTERPAMD  */
-    PERVERTEXEXT = 712,            /* PERVERTEXEXT  */
-    PERVERTEXNV = 713,             /* PERVERTEXNV  */
-    PERPRIMITIVENV = 714,          /* PERPRIMITIVENV  */
-    PERVIEWNV = 715,               /* PERVIEWNV  */
-    PERTASKNV = 716,               /* PERTASKNV  */
-    PERPRIMITIVEEXT = 717,         /* PERPRIMITIVEEXT  */
-    TASKPAYLOADWORKGROUPEXT = 718, /* TASKPAYLOADWORKGROUPEXT  */
-    PRECISE = 719                  /* PRECISE  */
+    FLOATE5M2_T = 318,             /* FLOATE5M2_T  */
+    FLOATE4M3_T = 319,             /* FLOATE4M3_T  */
+    BFLOAT16_T = 320,              /* BFLOAT16_T  */
+    FLOAT16_T = 321,               /* FLOAT16_T  */
+    FLOAT32_T = 322,               /* FLOAT32_T  */
+    DOUBLE = 323,                  /* DOUBLE  */
+    FLOAT64_T = 324,               /* FLOAT64_T  */
+    INT64_T = 325,                 /* INT64_T  */
+    UINT64_T = 326,                /* UINT64_T  */
+    INT32_T = 327,                 /* INT32_T  */
+    UINT32_T = 328,                /* UINT32_T  */
+    INT16_T = 329,                 /* INT16_T  */
+    UINT16_T = 330,                /* UINT16_T  */
+    INT8_T = 331,                  /* INT8_T  */
+    UINT8_T = 332,                 /* UINT8_T  */
+    I64VEC2 = 333,                 /* I64VEC2  */
+    I64VEC3 = 334,                 /* I64VEC3  */
+    I64VEC4 = 335,                 /* I64VEC4  */
+    U64VEC2 = 336,                 /* U64VEC2  */
+    U64VEC3 = 337,                 /* U64VEC3  */
+    U64VEC4 = 338,                 /* U64VEC4  */
+    I32VEC2 = 339,                 /* I32VEC2  */
+    I32VEC3 = 340,                 /* I32VEC3  */
+    I32VEC4 = 341,                 /* I32VEC4  */
+    U32VEC2 = 342,                 /* U32VEC2  */
+    U32VEC3 = 343,                 /* U32VEC3  */
+    U32VEC4 = 344,                 /* U32VEC4  */
+    I16VEC2 = 345,                 /* I16VEC2  */
+    I16VEC3 = 346,                 /* I16VEC3  */
+    I16VEC4 = 347,                 /* I16VEC4  */
+    U16VEC2 = 348,                 /* U16VEC2  */
+    U16VEC3 = 349,                 /* U16VEC3  */
+    U16VEC4 = 350,                 /* U16VEC4  */
+    I8VEC2 = 351,                  /* I8VEC2  */
+    I8VEC3 = 352,                  /* I8VEC3  */
+    I8VEC4 = 353,                  /* I8VEC4  */
+    U8VEC2 = 354,                  /* U8VEC2  */
+    U8VEC3 = 355,                  /* U8VEC3  */
+    U8VEC4 = 356,                  /* U8VEC4  */
+    DVEC2 = 357,                   /* DVEC2  */
+    DVEC3 = 358,                   /* DVEC3  */
+    DVEC4 = 359,                   /* DVEC4  */
+    DMAT2 = 360,                   /* DMAT2  */
+    DMAT3 = 361,                   /* DMAT3  */
+    DMAT4 = 362,                   /* DMAT4  */
+    BF16VEC2 = 363,                /* BF16VEC2  */
+    BF16VEC3 = 364,                /* BF16VEC3  */
+    BF16VEC4 = 365,                /* BF16VEC4  */
+    FE5M2VEC2 = 366,               /* FE5M2VEC2  */
+    FE5M2VEC3 = 367,               /* FE5M2VEC3  */
+    FE5M2VEC4 = 368,               /* FE5M2VEC4  */
+    FE4M3VEC2 = 369,               /* FE4M3VEC2  */
+    FE4M3VEC3 = 370,               /* FE4M3VEC3  */
+    FE4M3VEC4 = 371,               /* FE4M3VEC4  */
+    F16VEC2 = 372,                 /* F16VEC2  */
+    F16VEC3 = 373,                 /* F16VEC3  */
+    F16VEC4 = 374,                 /* F16VEC4  */
+    F16MAT2 = 375,                 /* F16MAT2  */
+    F16MAT3 = 376,                 /* F16MAT3  */
+    F16MAT4 = 377,                 /* F16MAT4  */
+    F32VEC2 = 378,                 /* F32VEC2  */
+    F32VEC3 = 379,                 /* F32VEC3  */
+    F32VEC4 = 380,                 /* F32VEC4  */
+    F32MAT2 = 381,                 /* F32MAT2  */
+    F32MAT3 = 382,                 /* F32MAT3  */
+    F32MAT4 = 383,                 /* F32MAT4  */
+    F64VEC2 = 384,                 /* F64VEC2  */
+    F64VEC3 = 385,                 /* F64VEC3  */
+    F64VEC4 = 386,                 /* F64VEC4  */
+    F64MAT2 = 387,                 /* F64MAT2  */
+    F64MAT3 = 388,                 /* F64MAT3  */
+    F64MAT4 = 389,                 /* F64MAT4  */
+    DMAT2X2 = 390,                 /* DMAT2X2  */
+    DMAT2X3 = 391,                 /* DMAT2X3  */
+    DMAT2X4 = 392,                 /* DMAT2X4  */
+    DMAT3X2 = 393,                 /* DMAT3X2  */
+    DMAT3X3 = 394,                 /* DMAT3X3  */
+    DMAT3X4 = 395,                 /* DMAT3X4  */
+    DMAT4X2 = 396,                 /* DMAT4X2  */
+    DMAT4X3 = 397,                 /* DMAT4X3  */
+    DMAT4X4 = 398,                 /* DMAT4X4  */
+    F16MAT2X2 = 399,               /* F16MAT2X2  */
+    F16MAT2X3 = 400,               /* F16MAT2X3  */
+    F16MAT2X4 = 401,               /* F16MAT2X4  */
+    F16MAT3X2 = 402,               /* F16MAT3X2  */
+    F16MAT3X3 = 403,               /* F16MAT3X3  */
+    F16MAT3X4 = 404,               /* F16MAT3X4  */
+    F16MAT4X2 = 405,               /* F16MAT4X2  */
+    F16MAT4X3 = 406,               /* F16MAT4X3  */
+    F16MAT4X4 = 407,               /* F16MAT4X4  */
+    F32MAT2X2 = 408,               /* F32MAT2X2  */
+    F32MAT2X3 = 409,               /* F32MAT2X3  */
+    F32MAT2X4 = 410,               /* F32MAT2X4  */
+    F32MAT3X2 = 411,               /* F32MAT3X2  */
+    F32MAT3X3 = 412,               /* F32MAT3X3  */
+    F32MAT3X4 = 413,               /* F32MAT3X4  */
+    F32MAT4X2 = 414,               /* F32MAT4X2  */
+    F32MAT4X3 = 415,               /* F32MAT4X3  */
+    F32MAT4X4 = 416,               /* F32MAT4X4  */
+    F64MAT2X2 = 417,               /* F64MAT2X2  */
+    F64MAT2X3 = 418,               /* F64MAT2X3  */
+    F64MAT2X4 = 419,               /* F64MAT2X4  */
+    F64MAT3X2 = 420,               /* F64MAT3X2  */
+    F64MAT3X3 = 421,               /* F64MAT3X3  */
+    F64MAT3X4 = 422,               /* F64MAT3X4  */
+    F64MAT4X2 = 423,               /* F64MAT4X2  */
+    F64MAT4X3 = 424,               /* F64MAT4X3  */
+    F64MAT4X4 = 425,               /* F64MAT4X4  */
+    ATOMIC_UINT = 426,             /* ATOMIC_UINT  */
+    ACCSTRUCTNV = 427,             /* ACCSTRUCTNV  */
+    ACCSTRUCTEXT = 428,            /* ACCSTRUCTEXT  */
+    RAYQUERYEXT = 429,             /* RAYQUERYEXT  */
+    FCOOPMATNV = 430,              /* FCOOPMATNV  */
+    ICOOPMATNV = 431,              /* ICOOPMATNV  */
+    UCOOPMATNV = 432,              /* UCOOPMATNV  */
+    COOPMAT = 433,                 /* COOPMAT  */
+    COOPVECNV = 434,               /* COOPVECNV  */
+    HITOBJECTNV = 435,             /* HITOBJECTNV  */
+    HITOBJECTATTRNV = 436,         /* HITOBJECTATTRNV  */
+    TENSORLAYOUTNV = 437,          /* TENSORLAYOUTNV  */
+    TENSORVIEWNV = 438,            /* TENSORVIEWNV  */
+    SAMPLERCUBEARRAY = 439,        /* SAMPLERCUBEARRAY  */
+    SAMPLERCUBEARRAYSHADOW = 440,  /* SAMPLERCUBEARRAYSHADOW  */
+    ISAMPLERCUBEARRAY = 441,       /* ISAMPLERCUBEARRAY  */
+    USAMPLERCUBEARRAY = 442,       /* USAMPLERCUBEARRAY  */
+    SAMPLER1D = 443,               /* SAMPLER1D  */
+    SAMPLER1DARRAY = 444,          /* SAMPLER1DARRAY  */
+    SAMPLER1DARRAYSHADOW = 445,    /* SAMPLER1DARRAYSHADOW  */
+    ISAMPLER1D = 446,              /* ISAMPLER1D  */
+    SAMPLER1DSHADOW = 447,         /* SAMPLER1DSHADOW  */
+    SAMPLER2DRECT = 448,           /* SAMPLER2DRECT  */
+    SAMPLER2DRECTSHADOW = 449,     /* SAMPLER2DRECTSHADOW  */
+    ISAMPLER2DRECT = 450,          /* ISAMPLER2DRECT  */
+    USAMPLER2DRECT = 451,          /* USAMPLER2DRECT  */
+    SAMPLERBUFFER = 452,           /* SAMPLERBUFFER  */
+    ISAMPLERBUFFER = 453,          /* ISAMPLERBUFFER  */
+    USAMPLERBUFFER = 454,          /* USAMPLERBUFFER  */
+    SAMPLER2DMS = 455,             /* SAMPLER2DMS  */
+    ISAMPLER2DMS = 456,            /* ISAMPLER2DMS  */
+    USAMPLER2DMS = 457,            /* USAMPLER2DMS  */
+    SAMPLER2DMSARRAY = 458,        /* SAMPLER2DMSARRAY  */
+    ISAMPLER2DMSARRAY = 459,       /* ISAMPLER2DMSARRAY  */
+    USAMPLER2DMSARRAY = 460,       /* USAMPLER2DMSARRAY  */
+    SAMPLEREXTERNALOES = 461,      /* SAMPLEREXTERNALOES  */
+    SAMPLEREXTERNAL2DY2YEXT = 462, /* SAMPLEREXTERNAL2DY2YEXT  */
+    ISAMPLER1DARRAY = 463,         /* ISAMPLER1DARRAY  */
+    USAMPLER1D = 464,              /* USAMPLER1D  */
+    USAMPLER1DARRAY = 465,         /* USAMPLER1DARRAY  */
+    F16SAMPLER1D = 466,            /* F16SAMPLER1D  */
+    F16SAMPLER2D = 467,            /* F16SAMPLER2D  */
+    F16SAMPLER3D = 468,            /* F16SAMPLER3D  */
+    F16SAMPLER2DRECT = 469,        /* F16SAMPLER2DRECT  */
+    F16SAMPLERCUBE = 470,          /* F16SAMPLERCUBE  */
+    F16SAMPLER1DARRAY = 471,       /* F16SAMPLER1DARRAY  */
+    F16SAMPLER2DARRAY = 472,       /* F16SAMPLER2DARRAY  */
+    F16SAMPLERCUBEARRAY = 473,     /* F16SAMPLERCUBEARRAY  */
+    F16SAMPLERBUFFER = 474,        /* F16SAMPLERBUFFER  */
+    F16SAMPLER2DMS = 475,          /* F16SAMPLER2DMS  */
+    F16SAMPLER2DMSARRAY = 476,     /* F16SAMPLER2DMSARRAY  */
+    F16SAMPLER1DSHADOW = 477,      /* F16SAMPLER1DSHADOW  */
+    F16SAMPLER2DSHADOW = 478,      /* F16SAMPLER2DSHADOW  */
+    F16SAMPLER1DARRAYSHADOW = 479, /* F16SAMPLER1DARRAYSHADOW  */
+    F16SAMPLER2DARRAYSHADOW = 480, /* F16SAMPLER2DARRAYSHADOW  */
+    F16SAMPLER2DRECTSHADOW = 481,  /* F16SAMPLER2DRECTSHADOW  */
+    F16SAMPLERCUBESHADOW = 482,    /* F16SAMPLERCUBESHADOW  */
+    F16SAMPLERCUBEARRAYSHADOW = 483, /* F16SAMPLERCUBEARRAYSHADOW  */
+    IMAGE1D = 484,                 /* IMAGE1D  */
+    IIMAGE1D = 485,                /* IIMAGE1D  */
+    UIMAGE1D = 486,                /* UIMAGE1D  */
+    IMAGE2D = 487,                 /* IMAGE2D  */
+    IIMAGE2D = 488,                /* IIMAGE2D  */
+    UIMAGE2D = 489,                /* UIMAGE2D  */
+    IMAGE3D = 490,                 /* IMAGE3D  */
+    IIMAGE3D = 491,                /* IIMAGE3D  */
+    UIMAGE3D = 492,                /* UIMAGE3D  */
+    IMAGE2DRECT = 493,             /* IMAGE2DRECT  */
+    IIMAGE2DRECT = 494,            /* IIMAGE2DRECT  */
+    UIMAGE2DRECT = 495,            /* UIMAGE2DRECT  */
+    IMAGECUBE = 496,               /* IMAGECUBE  */
+    IIMAGECUBE = 497,              /* IIMAGECUBE  */
+    UIMAGECUBE = 498,              /* UIMAGECUBE  */
+    IMAGEBUFFER = 499,             /* IMAGEBUFFER  */
+    IIMAGEBUFFER = 500,            /* IIMAGEBUFFER  */
+    UIMAGEBUFFER = 501,            /* UIMAGEBUFFER  */
+    IMAGE1DARRAY = 502,            /* IMAGE1DARRAY  */
+    IIMAGE1DARRAY = 503,           /* IIMAGE1DARRAY  */
+    UIMAGE1DARRAY = 504,           /* UIMAGE1DARRAY  */
+    IMAGE2DARRAY = 505,            /* IMAGE2DARRAY  */
+    IIMAGE2DARRAY = 506,           /* IIMAGE2DARRAY  */
+    UIMAGE2DARRAY = 507,           /* UIMAGE2DARRAY  */
+    IMAGECUBEARRAY = 508,          /* IMAGECUBEARRAY  */
+    IIMAGECUBEARRAY = 509,         /* IIMAGECUBEARRAY  */
+    UIMAGECUBEARRAY = 510,         /* UIMAGECUBEARRAY  */
+    IMAGE2DMS = 511,               /* IMAGE2DMS  */
+    IIMAGE2DMS = 512,              /* IIMAGE2DMS  */
+    UIMAGE2DMS = 513,              /* UIMAGE2DMS  */
+    IMAGE2DMSARRAY = 514,          /* IMAGE2DMSARRAY  */
+    IIMAGE2DMSARRAY = 515,         /* IIMAGE2DMSARRAY  */
+    UIMAGE2DMSARRAY = 516,         /* UIMAGE2DMSARRAY  */
+    F16IMAGE1D = 517,              /* F16IMAGE1D  */
+    F16IMAGE2D = 518,              /* F16IMAGE2D  */
+    F16IMAGE3D = 519,              /* F16IMAGE3D  */
+    F16IMAGE2DRECT = 520,          /* F16IMAGE2DRECT  */
+    F16IMAGECUBE = 521,            /* F16IMAGECUBE  */
+    F16IMAGE1DARRAY = 522,         /* F16IMAGE1DARRAY  */
+    F16IMAGE2DARRAY = 523,         /* F16IMAGE2DARRAY  */
+    F16IMAGECUBEARRAY = 524,       /* F16IMAGECUBEARRAY  */
+    F16IMAGEBUFFER = 525,          /* F16IMAGEBUFFER  */
+    F16IMAGE2DMS = 526,            /* F16IMAGE2DMS  */
+    F16IMAGE2DMSARRAY = 527,       /* F16IMAGE2DMSARRAY  */
+    I64IMAGE1D = 528,              /* I64IMAGE1D  */
+    U64IMAGE1D = 529,              /* U64IMAGE1D  */
+    I64IMAGE2D = 530,              /* I64IMAGE2D  */
+    U64IMAGE2D = 531,              /* U64IMAGE2D  */
+    I64IMAGE3D = 532,              /* I64IMAGE3D  */
+    U64IMAGE3D = 533,              /* U64IMAGE3D  */
+    I64IMAGE2DRECT = 534,          /* I64IMAGE2DRECT  */
+    U64IMAGE2DRECT = 535,          /* U64IMAGE2DRECT  */
+    I64IMAGECUBE = 536,            /* I64IMAGECUBE  */
+    U64IMAGECUBE = 537,            /* U64IMAGECUBE  */
+    I64IMAGEBUFFER = 538,          /* I64IMAGEBUFFER  */
+    U64IMAGEBUFFER = 539,          /* U64IMAGEBUFFER  */
+    I64IMAGE1DARRAY = 540,         /* I64IMAGE1DARRAY  */
+    U64IMAGE1DARRAY = 541,         /* U64IMAGE1DARRAY  */
+    I64IMAGE2DARRAY = 542,         /* I64IMAGE2DARRAY  */
+    U64IMAGE2DARRAY = 543,         /* U64IMAGE2DARRAY  */
+    I64IMAGECUBEARRAY = 544,       /* I64IMAGECUBEARRAY  */
+    U64IMAGECUBEARRAY = 545,       /* U64IMAGECUBEARRAY  */
+    I64IMAGE2DMS = 546,            /* I64IMAGE2DMS  */
+    U64IMAGE2DMS = 547,            /* U64IMAGE2DMS  */
+    I64IMAGE2DMSARRAY = 548,       /* I64IMAGE2DMSARRAY  */
+    U64IMAGE2DMSARRAY = 549,       /* U64IMAGE2DMSARRAY  */
+    TEXTURECUBEARRAY = 550,        /* TEXTURECUBEARRAY  */
+    ITEXTURECUBEARRAY = 551,       /* ITEXTURECUBEARRAY  */
+    UTEXTURECUBEARRAY = 552,       /* UTEXTURECUBEARRAY  */
+    TEXTURE1D = 553,               /* TEXTURE1D  */
+    ITEXTURE1D = 554,              /* ITEXTURE1D  */
+    UTEXTURE1D = 555,              /* UTEXTURE1D  */
+    TEXTURE1DARRAY = 556,          /* TEXTURE1DARRAY  */
+    ITEXTURE1DARRAY = 557,         /* ITEXTURE1DARRAY  */
+    UTEXTURE1DARRAY = 558,         /* UTEXTURE1DARRAY  */
+    TEXTURE2DRECT = 559,           /* TEXTURE2DRECT  */
+    ITEXTURE2DRECT = 560,          /* ITEXTURE2DRECT  */
+    UTEXTURE2DRECT = 561,          /* UTEXTURE2DRECT  */
+    TEXTUREBUFFER = 562,           /* TEXTUREBUFFER  */
+    ITEXTUREBUFFER = 563,          /* ITEXTUREBUFFER  */
+    UTEXTUREBUFFER = 564,          /* UTEXTUREBUFFER  */
+    TEXTURE2DMS = 565,             /* TEXTURE2DMS  */
+    ITEXTURE2DMS = 566,            /* ITEXTURE2DMS  */
+    UTEXTURE2DMS = 567,            /* UTEXTURE2DMS  */
+    TEXTURE2DMSARRAY = 568,        /* TEXTURE2DMSARRAY  */
+    ITEXTURE2DMSARRAY = 569,       /* ITEXTURE2DMSARRAY  */
+    UTEXTURE2DMSARRAY = 570,       /* UTEXTURE2DMSARRAY  */
+    F16TEXTURE1D = 571,            /* F16TEXTURE1D  */
+    F16TEXTURE2D = 572,            /* F16TEXTURE2D  */
+    F16TEXTURE3D = 573,            /* F16TEXTURE3D  */
+    F16TEXTURE2DRECT = 574,        /* F16TEXTURE2DRECT  */
+    F16TEXTURECUBE = 575,          /* F16TEXTURECUBE  */
+    F16TEXTURE1DARRAY = 576,       /* F16TEXTURE1DARRAY  */
+    F16TEXTURE2DARRAY = 577,       /* F16TEXTURE2DARRAY  */
+    F16TEXTURECUBEARRAY = 578,     /* F16TEXTURECUBEARRAY  */
+    F16TEXTUREBUFFER = 579,        /* F16TEXTUREBUFFER  */
+    F16TEXTURE2DMS = 580,          /* F16TEXTURE2DMS  */
+    F16TEXTURE2DMSARRAY = 581,     /* F16TEXTURE2DMSARRAY  */
+    SUBPASSINPUT = 582,            /* SUBPASSINPUT  */
+    SUBPASSINPUTMS = 583,          /* SUBPASSINPUTMS  */
+    ISUBPASSINPUT = 584,           /* ISUBPASSINPUT  */
+    ISUBPASSINPUTMS = 585,         /* ISUBPASSINPUTMS  */
+    USUBPASSINPUT = 586,           /* USUBPASSINPUT  */
+    USUBPASSINPUTMS = 587,         /* USUBPASSINPUTMS  */
+    F16SUBPASSINPUT = 588,         /* F16SUBPASSINPUT  */
+    F16SUBPASSINPUTMS = 589,       /* F16SUBPASSINPUTMS  */
+    SPIRV_INSTRUCTION = 590,       /* SPIRV_INSTRUCTION  */
+    SPIRV_EXECUTION_MODE = 591,    /* SPIRV_EXECUTION_MODE  */
+    SPIRV_EXECUTION_MODE_ID = 592, /* SPIRV_EXECUTION_MODE_ID  */
+    SPIRV_DECORATE = 593,          /* SPIRV_DECORATE  */
+    SPIRV_DECORATE_ID = 594,       /* SPIRV_DECORATE_ID  */
+    SPIRV_DECORATE_STRING = 595,   /* SPIRV_DECORATE_STRING  */
+    SPIRV_TYPE = 596,              /* SPIRV_TYPE  */
+    SPIRV_STORAGE_CLASS = 597,     /* SPIRV_STORAGE_CLASS  */
+    SPIRV_BY_REFERENCE = 598,      /* SPIRV_BY_REFERENCE  */
+    SPIRV_LITERAL = 599,           /* SPIRV_LITERAL  */
+    ATTACHMENTEXT = 600,           /* ATTACHMENTEXT  */
+    IATTACHMENTEXT = 601,          /* IATTACHMENTEXT  */
+    UATTACHMENTEXT = 602,          /* UATTACHMENTEXT  */
+    LEFT_OP = 603,                 /* LEFT_OP  */
+    RIGHT_OP = 604,                /* RIGHT_OP  */
+    INC_OP = 605,                  /* INC_OP  */
+    DEC_OP = 606,                  /* DEC_OP  */
+    LE_OP = 607,                   /* LE_OP  */
+    GE_OP = 608,                   /* GE_OP  */
+    EQ_OP = 609,                   /* EQ_OP  */
+    NE_OP = 610,                   /* NE_OP  */
+    AND_OP = 611,                  /* AND_OP  */
+    OR_OP = 612,                   /* OR_OP  */
+    XOR_OP = 613,                  /* XOR_OP  */
+    MUL_ASSIGN = 614,              /* MUL_ASSIGN  */
+    DIV_ASSIGN = 615,              /* DIV_ASSIGN  */
+    ADD_ASSIGN = 616,              /* ADD_ASSIGN  */
+    MOD_ASSIGN = 617,              /* MOD_ASSIGN  */
+    LEFT_ASSIGN = 618,             /* LEFT_ASSIGN  */
+    RIGHT_ASSIGN = 619,            /* RIGHT_ASSIGN  */
+    AND_ASSIGN = 620,              /* AND_ASSIGN  */
+    XOR_ASSIGN = 621,              /* XOR_ASSIGN  */
+    OR_ASSIGN = 622,               /* OR_ASSIGN  */
+    SUB_ASSIGN = 623,              /* SUB_ASSIGN  */
+    STRING_LITERAL = 624,          /* STRING_LITERAL  */
+    LEFT_PAREN = 625,              /* LEFT_PAREN  */
+    RIGHT_PAREN = 626,             /* RIGHT_PAREN  */
+    LEFT_BRACKET = 627,            /* LEFT_BRACKET  */
+    RIGHT_BRACKET = 628,           /* RIGHT_BRACKET  */
+    LEFT_BRACE = 629,              /* LEFT_BRACE  */
+    RIGHT_BRACE = 630,             /* RIGHT_BRACE  */
+    DOT = 631,                     /* DOT  */
+    COMMA = 632,                   /* COMMA  */
+    COLON = 633,                   /* COLON  */
+    EQUAL = 634,                   /* EQUAL  */
+    SEMICOLON = 635,               /* SEMICOLON  */
+    BANG = 636,                    /* BANG  */
+    DASH = 637,                    /* DASH  */
+    TILDE = 638,                   /* TILDE  */
+    PLUS = 639,                    /* PLUS  */
+    STAR = 640,                    /* STAR  */
+    SLASH = 641,                   /* SLASH  */
+    PERCENT = 642,                 /* PERCENT  */
+    LEFT_ANGLE = 643,              /* LEFT_ANGLE  */
+    RIGHT_ANGLE = 644,             /* RIGHT_ANGLE  */
+    VERTICAL_BAR = 645,            /* VERTICAL_BAR  */
+    CARET = 646,                   /* CARET  */
+    AMPERSAND = 647,               /* AMPERSAND  */
+    QUESTION = 648,                /* QUESTION  */
+    INVARIANT = 649,               /* INVARIANT  */
+    HIGH_PRECISION = 650,          /* HIGH_PRECISION  */
+    MEDIUM_PRECISION = 651,        /* MEDIUM_PRECISION  */
+    LOW_PRECISION = 652,           /* LOW_PRECISION  */
+    PRECISION = 653,               /* PRECISION  */
+    PACKED = 654,                  /* PACKED  */
+    RESOURCE = 655,                /* RESOURCE  */
+    SUPERP = 656,                  /* SUPERP  */
+    FLOATCONSTANT = 657,           /* FLOATCONSTANT  */
+    INTCONSTANT = 658,             /* INTCONSTANT  */
+    UINTCONSTANT = 659,            /* UINTCONSTANT  */
+    BOOLCONSTANT = 660,            /* BOOLCONSTANT  */
+    IDENTIFIER = 661,              /* IDENTIFIER  */
+    TYPE_NAME = 662,               /* TYPE_NAME  */
+    CENTROID = 663,                /* CENTROID  */
+    IN = 664,                      /* IN  */
+    OUT = 665,                     /* OUT  */
+    INOUT = 666,                   /* INOUT  */
+    STRUCT = 667,                  /* STRUCT  */
+    VOID = 668,                    /* VOID  */
+    WHILE = 669,                   /* WHILE  */
+    BREAK = 670,                   /* BREAK  */
+    CONTINUE = 671,                /* CONTINUE  */
+    DO = 672,                      /* DO  */
+    ELSE = 673,                    /* ELSE  */
+    FOR = 674,                     /* FOR  */
+    IF = 675,                      /* IF  */
+    DISCARD = 676,                 /* DISCARD  */
+    RETURN = 677,                  /* RETURN  */
+    SWITCH = 678,                  /* SWITCH  */
+    CASE = 679,                    /* CASE  */
+    DEFAULT = 680,                 /* DEFAULT  */
+    TERMINATE_INVOCATION = 681,    /* TERMINATE_INVOCATION  */
+    TERMINATE_RAY = 682,           /* TERMINATE_RAY  */
+    IGNORE_INTERSECTION = 683,     /* IGNORE_INTERSECTION  */
+    UNIFORM = 684,                 /* UNIFORM  */
+    SHARED = 685,                  /* SHARED  */
+    BUFFER = 686,                  /* BUFFER  */
+    TILEIMAGEEXT = 687,            /* TILEIMAGEEXT  */
+    FLAT = 688,                    /* FLAT  */
+    SMOOTH = 689,                  /* SMOOTH  */
+    LAYOUT = 690,                  /* LAYOUT  */
+    DOUBLECONSTANT = 691,          /* DOUBLECONSTANT  */
+    INT16CONSTANT = 692,           /* INT16CONSTANT  */
+    UINT16CONSTANT = 693,          /* UINT16CONSTANT  */
+    FLOAT16CONSTANT = 694,         /* FLOAT16CONSTANT  */
+    INT32CONSTANT = 695,           /* INT32CONSTANT  */
+    UINT32CONSTANT = 696,          /* UINT32CONSTANT  */
+    INT64CONSTANT = 697,           /* INT64CONSTANT  */
+    UINT64CONSTANT = 698,          /* UINT64CONSTANT  */
+    SUBROUTINE = 699,              /* SUBROUTINE  */
+    DEMOTE = 700,                  /* DEMOTE  */
+    FUNCTION = 701,                /* FUNCTION  */
+    PAYLOADNV = 702,               /* PAYLOADNV  */
+    PAYLOADINNV = 703,             /* PAYLOADINNV  */
+    HITATTRNV = 704,               /* HITATTRNV  */
+    CALLDATANV = 705,              /* CALLDATANV  */
+    CALLDATAINNV = 706,            /* CALLDATAINNV  */
+    PAYLOADEXT = 707,              /* PAYLOADEXT  */
+    PAYLOADINEXT = 708,            /* PAYLOADINEXT  */
+    HITATTREXT = 709,              /* HITATTREXT  */
+    CALLDATAEXT = 710,             /* CALLDATAEXT  */
+    CALLDATAINEXT = 711,           /* CALLDATAINEXT  */
+    PATCH = 712,                   /* PATCH  */
+    SAMPLE = 713,                  /* SAMPLE  */
+    NONUNIFORM = 714,              /* NONUNIFORM  */
+    COHERENT = 715,                /* COHERENT  */
+    VOLATILE = 716,                /* VOLATILE  */
+    RESTRICT = 717,                /* RESTRICT  */
+    READONLY = 718,                /* READONLY  */
+    WRITEONLY = 719,               /* WRITEONLY  */
+    NONTEMPORAL = 720,             /* NONTEMPORAL  */
+    DEVICECOHERENT = 721,          /* DEVICECOHERENT  */
+    QUEUEFAMILYCOHERENT = 722,     /* QUEUEFAMILYCOHERENT  */
+    WORKGROUPCOHERENT = 723,       /* WORKGROUPCOHERENT  */
+    SUBGROUPCOHERENT = 724,        /* SUBGROUPCOHERENT  */
+    NONPRIVATE = 725,              /* NONPRIVATE  */
+    SHADERCALLCOHERENT = 726,      /* SHADERCALLCOHERENT  */
+    NOPERSPECTIVE = 727,           /* NOPERSPECTIVE  */
+    EXPLICITINTERPAMD = 728,       /* EXPLICITINTERPAMD  */
+    PERVERTEXEXT = 729,            /* PERVERTEXEXT  */
+    PERVERTEXNV = 730,             /* PERVERTEXNV  */
+    PERPRIMITIVENV = 731,          /* PERPRIMITIVENV  */
+    PERVIEWNV = 732,               /* PERVIEWNV  */
+    PERTASKNV = 733,               /* PERTASKNV  */
+    PERPRIMITIVEEXT = 734,         /* PERPRIMITIVEEXT  */
+    TASKPAYLOADWORKGROUPEXT = 735, /* TASKPAYLOADWORKGROUPEXT  */
+    PRECISE = 736                  /* PRECISE  */
   };
   typedef enum yytokentype yytoken_kind_t;
 #endif
@@ -563,7 +580,7 @@ union YYSTYPE
         glslang::TTypeParameters* typeParameters;
     } interm;
 
-#line 567 "MachineIndependent/glslang_tab.cpp.h"
+#line 584 "MachineIndependent/glslang_tab.cpp.h"
 
 };
 typedef union YYSTYPE YYSTYPE;

+ 84 - 186
src/libraries/glslang/glslang/MachineIndependent/intermOut.cpp

@@ -204,6 +204,13 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
 
     OutputTreeText(out, node, depth);
 
+    if (IsOpNumericConv(node->getAsOperator()->getOp())) {
+        out.debug << "Convert " << TType::getBasicString(node->getOperand()->getType().getBasicType()) << " to " << TType::getBasicString(node->getType().getBasicType());
+        out.debug << " (" << node->getCompleteString() << ")";
+        out.debug << "\n";
+        return true;
+    }
+
     switch (node->getOp()) {
     case EOpNegative:       out.debug << "Negate value";         break;
     case EOpVectorLogicalNot:
@@ -216,192 +223,6 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
     case EOpPreDecrement:   out.debug << "Pre-Decrement";        break;
     case EOpCopyObject:     out.debug << "copy object";          break;
 
-    // * -> bool
-    case EOpConvInt8ToBool:    out.debug << "Convert int8_t to bool";  break;
-    case EOpConvUint8ToBool:   out.debug << "Convert uint8_t to bool"; break;
-    case EOpConvInt16ToBool:   out.debug << "Convert int16_t to bool"; break;
-    case EOpConvUint16ToBool:  out.debug << "Convert uint16_t to bool";break;
-    case EOpConvIntToBool:     out.debug << "Convert int to bool";     break;
-    case EOpConvUintToBool:    out.debug << "Convert uint to bool";    break;
-    case EOpConvInt64ToBool:   out.debug << "Convert int64 to bool";   break;
-    case EOpConvUint64ToBool:  out.debug << "Convert uint64 to bool";  break;
-    case EOpConvFloat16ToBool: out.debug << "Convert float16_t to bool";   break;
-    case EOpConvFloatToBool:   out.debug << "Convert float to bool";   break;
-    case EOpConvDoubleToBool:  out.debug << "Convert double to bool";  break;
-
-    // bool -> *
-    case EOpConvBoolToInt8:    out.debug << "Convert bool to int8_t";  break;
-    case EOpConvBoolToUint8:   out.debug << "Convert bool to uint8_t"; break;
-    case EOpConvBoolToInt16:   out.debug << "Convert bool to in16t_t"; break;
-    case EOpConvBoolToUint16:  out.debug << "Convert bool to uint16_t";break;
-    case EOpConvBoolToInt:     out.debug << "Convert bool to int"  ;   break;
-    case EOpConvBoolToUint:    out.debug << "Convert bool to uint";    break;
-    case EOpConvBoolToInt64:   out.debug << "Convert bool to int64"; break;
-    case EOpConvBoolToUint64:  out.debug << "Convert bool to uint64";break;
-    case EOpConvBoolToFloat16: out.debug << "Convert bool to float16_t";   break;
-    case EOpConvBoolToFloat:   out.debug << "Convert bool to float";   break;
-    case EOpConvBoolToDouble:  out.debug << "Convert bool to double";   break;
-
-    // int8_t -> (u)int*
-    case EOpConvInt8ToInt16:   out.debug << "Convert int8_t to int16_t";break;
-    case EOpConvInt8ToInt:     out.debug << "Convert int8_t to int";    break;
-    case EOpConvInt8ToInt64:   out.debug << "Convert int8_t to int64";   break;
-    case EOpConvInt8ToUint8:   out.debug << "Convert int8_t to uint8_t";break;
-    case EOpConvInt8ToUint16:  out.debug << "Convert int8_t to uint16_t";break;
-    case EOpConvInt8ToUint:    out.debug << "Convert int8_t to uint";    break;
-    case EOpConvInt8ToUint64:  out.debug << "Convert int8_t to uint64";   break;
-
-    // uint8_t -> (u)int*
-    case EOpConvUint8ToInt8:    out.debug << "Convert uint8_t to int8_t";break;
-    case EOpConvUint8ToInt16:   out.debug << "Convert uint8_t to int16_t";break;
-    case EOpConvUint8ToInt:     out.debug << "Convert uint8_t to int";    break;
-    case EOpConvUint8ToInt64:   out.debug << "Convert uint8_t to int64";   break;
-    case EOpConvUint8ToUint16:  out.debug << "Convert uint8_t to uint16_t";break;
-    case EOpConvUint8ToUint:    out.debug << "Convert uint8_t to uint";    break;
-    case EOpConvUint8ToUint64:  out.debug << "Convert uint8_t to uint64";   break;
-
-    // int8_t -> float*
-    case EOpConvInt8ToFloat16:  out.debug << "Convert int8_t to float16_t";break;
-    case EOpConvInt8ToFloat:    out.debug << "Convert int8_t to float";    break;
-    case EOpConvInt8ToDouble:   out.debug << "Convert int8_t to double";   break;
-
-    // uint8_t -> float*
-    case EOpConvUint8ToFloat16: out.debug << "Convert uint8_t to float16_t";break;
-    case EOpConvUint8ToFloat:   out.debug << "Convert uint8_t to float";    break;
-    case EOpConvUint8ToDouble:  out.debug << "Convert uint8_t to double";   break;
-
-    // int16_t -> (u)int*
-    case EOpConvInt16ToInt8:    out.debug << "Convert int16_t to int8_t";break;
-    case EOpConvInt16ToInt:     out.debug << "Convert int16_t to int";    break;
-    case EOpConvInt16ToInt64:   out.debug << "Convert int16_t to int64";   break;
-    case EOpConvInt16ToUint8:   out.debug << "Convert int16_t to uint8_t";break;
-    case EOpConvInt16ToUint16:  out.debug << "Convert int16_t to uint16_t";break;
-    case EOpConvInt16ToUint:    out.debug << "Convert int16_t to uint";    break;
-    case EOpConvInt16ToUint64:  out.debug << "Convert int16_t to uint64";   break;
-
-    // int16_t -> float*
-    case EOpConvInt16ToFloat16:  out.debug << "Convert int16_t to float16_t";break;
-    case EOpConvInt16ToFloat:    out.debug << "Convert int16_t to float";    break;
-    case EOpConvInt16ToDouble:   out.debug << "Convert int16_t to double";   break;
-
-    // uint16_t -> (u)int*
-    case EOpConvUint16ToInt8:    out.debug << "Convert uint16_t to int8_t";break;
-    case EOpConvUint16ToInt16:   out.debug << "Convert uint16_t to int16_t";break;
-    case EOpConvUint16ToInt:     out.debug << "Convert uint16_t to int";    break;
-    case EOpConvUint16ToInt64:   out.debug << "Convert uint16_t to int64";   break;
-    case EOpConvUint16ToUint8:   out.debug << "Convert uint16_t to uint8_t";break;
-    case EOpConvUint16ToUint:    out.debug << "Convert uint16_t to uint";    break;
-    case EOpConvUint16ToUint64:  out.debug << "Convert uint16_t to uint64";   break;
-
-    // uint16_t -> float*
-    case EOpConvUint16ToFloat16: out.debug << "Convert uint16_t to float16_t";break;
-    case EOpConvUint16ToFloat:   out.debug << "Convert uint16_t to float";    break;
-    case EOpConvUint16ToDouble:  out.debug << "Convert uint16_t to double";   break;
-
-    // int32_t -> (u)int*
-    case EOpConvIntToInt8:    out.debug << "Convert int to int8_t";break;
-    case EOpConvIntToInt16:   out.debug << "Convert int to int16_t";break;
-    case EOpConvIntToInt64:   out.debug << "Convert int to int64";   break;
-    case EOpConvIntToUint8:   out.debug << "Convert int to uint8_t";break;
-    case EOpConvIntToUint16:  out.debug << "Convert int to uint16_t";break;
-    case EOpConvIntToUint:    out.debug << "Convert int to uint";    break;
-    case EOpConvIntToUint64:  out.debug << "Convert int to uint64";   break;
-
-    // int32_t -> float*
-    case EOpConvIntToFloat16:  out.debug << "Convert int to float16_t";break;
-    case EOpConvIntToFloat:    out.debug << "Convert int to float";    break;
-    case EOpConvIntToDouble:   out.debug << "Convert int to double";   break;
-
-    // uint32_t -> (u)int*
-    case EOpConvUintToInt8:    out.debug << "Convert uint to int8_t";break;
-    case EOpConvUintToInt16:   out.debug << "Convert uint to int16_t";break;
-    case EOpConvUintToInt:     out.debug << "Convert uint to int";break;
-    case EOpConvUintToInt64:   out.debug << "Convert uint to int64";   break;
-    case EOpConvUintToUint8:   out.debug << "Convert uint to uint8_t";break;
-    case EOpConvUintToUint16:  out.debug << "Convert uint to uint16_t";break;
-    case EOpConvUintToUint64:  out.debug << "Convert uint to uint64";   break;
-
-    // uint32_t -> float*
-    case EOpConvUintToFloat16: out.debug << "Convert uint to float16_t";break;
-    case EOpConvUintToFloat:   out.debug << "Convert uint to float";    break;
-    case EOpConvUintToDouble:  out.debug << "Convert uint to double";   break;
-
-    // int64 -> (u)int*
-    case EOpConvInt64ToInt8:    out.debug << "Convert int64 to int8_t";  break;
-    case EOpConvInt64ToInt16:   out.debug << "Convert int64 to int16_t"; break;
-    case EOpConvInt64ToInt:     out.debug << "Convert int64 to int";   break;
-    case EOpConvInt64ToUint8:   out.debug << "Convert int64 to uint8_t";break;
-    case EOpConvInt64ToUint16:  out.debug << "Convert int64 to uint16_t";break;
-    case EOpConvInt64ToUint:    out.debug << "Convert int64 to uint";    break;
-    case EOpConvInt64ToUint64:  out.debug << "Convert int64 to uint64";   break;
-
-     // int64 -> float*
-    case EOpConvInt64ToFloat16:  out.debug << "Convert int64 to float16_t";break;
-    case EOpConvInt64ToFloat:    out.debug << "Convert int64 to float";    break;
-    case EOpConvInt64ToDouble:   out.debug << "Convert int64 to double";   break;
-
-    // uint64 -> (u)int*
-    case EOpConvUint64ToInt8:    out.debug << "Convert uint64 to int8_t";break;
-    case EOpConvUint64ToInt16:   out.debug << "Convert uint64 to int16_t";break;
-    case EOpConvUint64ToInt:     out.debug << "Convert uint64 to int";    break;
-    case EOpConvUint64ToInt64:   out.debug << "Convert uint64 to int64";   break;
-    case EOpConvUint64ToUint8:   out.debug << "Convert uint64 to uint8_t";break;
-    case EOpConvUint64ToUint16:  out.debug << "Convert uint64 to uint16";    break;
-    case EOpConvUint64ToUint:    out.debug << "Convert uint64 to uint";   break;
-
-    // uint64 -> float*
-    case EOpConvUint64ToFloat16: out.debug << "Convert uint64 to float16_t";break;
-    case EOpConvUint64ToFloat:   out.debug << "Convert uint64 to float";    break;
-    case EOpConvUint64ToDouble:  out.debug << "Convert uint64 to double";   break;
-
-    // float16_t -> int*
-    case EOpConvFloat16ToInt8:  out.debug << "Convert float16_t to int8_t"; break;
-    case EOpConvFloat16ToInt16: out.debug << "Convert float16_t to int16_t"; break;
-    case EOpConvFloat16ToInt:   out.debug << "Convert float16_t to int"; break;
-    case EOpConvFloat16ToInt64: out.debug << "Convert float16_t to int64"; break;
-
-    // float16_t -> uint*
-    case EOpConvFloat16ToUint8:  out.debug << "Convert float16_t to uint8_t"; break;
-    case EOpConvFloat16ToUint16: out.debug << "Convert float16_t to uint16_t"; break;
-    case EOpConvFloat16ToUint:   out.debug << "Convert float16_t to uint"; break;
-    case EOpConvFloat16ToUint64: out.debug << "Convert float16_t to uint64"; break;
-
-    // float16_t -> float*
-    case EOpConvFloat16ToFloat:  out.debug << "Convert float16_t to float"; break;
-    case EOpConvFloat16ToDouble: out.debug << "Convert float16_t to double"; break;
-
-    // float32 -> float*
-    case EOpConvFloatToFloat16: out.debug << "Convert float to float16_t"; break;
-    case EOpConvFloatToDouble:  out.debug << "Convert float to double"; break;
-
-    // float32_t -> int*
-    case EOpConvFloatToInt8:  out.debug << "Convert float to int8_t"; break;
-    case EOpConvFloatToInt16: out.debug << "Convert float to int16_t"; break;
-    case EOpConvFloatToInt:   out.debug << "Convert float to int"; break;
-    case EOpConvFloatToInt64: out.debug << "Convert float to int64"; break;
-
-    // float32_t -> uint*
-    case EOpConvFloatToUint8:  out.debug << "Convert float to uint8_t"; break;
-    case EOpConvFloatToUint16: out.debug << "Convert float to uint16_t"; break;
-    case EOpConvFloatToUint:   out.debug << "Convert float to uint"; break;
-    case EOpConvFloatToUint64: out.debug << "Convert float to uint64"; break;
-
-    // double -> float*
-    case EOpConvDoubleToFloat16: out.debug << "Convert double to float16_t"; break;
-    case EOpConvDoubleToFloat:   out.debug << "Convert double to float"; break;
-
-    // double -> int*
-    case EOpConvDoubleToInt8:  out.debug << "Convert double to int8_t"; break;
-    case EOpConvDoubleToInt16: out.debug << "Convert double to int16_t"; break;
-    case EOpConvDoubleToInt:   out.debug << "Convert double to int"; break;
-    case EOpConvDoubleToInt64: out.debug << "Convert double to int64"; break;
-
-    // float32_t -> uint*
-    case EOpConvDoubleToUint8:  out.debug << "Convert double to uint8_t"; break;
-    case EOpConvDoubleToUint16: out.debug << "Convert double to uint16_t"; break;
-    case EOpConvDoubleToUint:   out.debug << "Convert double to uint"; break;
-    case EOpConvDoubleToUint64: out.debug << "Convert double to uint64"; break;
-
     case EOpConvUint64ToPtr:  out.debug << "Convert uint64_t to pointer";   break;
     case EOpConvPtrToUint64:  out.debug << "Convert pointer to uint64_t";   break;
 
@@ -673,6 +494,17 @@ bool TOutputTraverser::visitUnary(TVisit /* visit */, TIntermUnary* node)
 
     case EOpSpirvInst: out.debug << "spirv_instruction"; break;
 
+    case EOpCreateTensorLayoutNV:           out.debug << "createTensorLayoutNV"; break;
+    case EOpTensorLayoutSetBlockSizeNV:     out.debug << "setTensorLayoutBlockSizeNV"; break;
+    case EOpTensorLayoutSetDimensionNV:     out.debug << "setTensorLayoutDimensionNV"; break;
+    case EOpTensorLayoutSetStrideNV:        out.debug << "setTensorLayoutStrideNV"; break;
+    case EOpTensorLayoutSliceNV:            out.debug << "sliceTensorLayoutNV"; break;
+    case EOpTensorLayoutSetClampValueNV:    out.debug << "setTensorLayoutClampValueNV"; break;
+    case EOpCreateTensorViewNV:             out.debug << "createTensorViewNV"; break;
+    case EOpTensorViewSetDimensionNV:       out.debug << "setTensorViewDimensionsNV"; break;
+    case EOpTensorViewSetStrideNV:          out.debug << "setTensorViewStrideNV"; break;
+    case EOpTensorViewSetClipNV:            out.debug << "setTensorViewClipNV"; break;
+
     default: out.debug.message(EPrefixError, "Bad unary op");
     }
 
@@ -793,6 +625,18 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpConstructBMat4x2: out.debug << "Construct bmat4x2"; break;
     case EOpConstructBMat4x3: out.debug << "Construct bmat4x3"; break;
     case EOpConstructBMat4x4: out.debug << "Construct bmat4";   break;
+    case EOpConstructBFloat16:  out.debug << "Construct bfloat16_t"; break;
+    case EOpConstructBF16Vec2:  out.debug << "Construct bf16vec2";   break;
+    case EOpConstructBF16Vec3:  out.debug << "Construct bf16vec3";   break;
+    case EOpConstructBF16Vec4:  out.debug << "Construct bf16vec4";   break;
+    case EOpConstructFloatE5M2:  out.debug << "Construct floate5m2_t"; break;
+    case EOpConstructFloatE5M2Vec2:  out.debug << "Construct fe5m2vec2";   break;
+    case EOpConstructFloatE5M2Vec3:  out.debug << "Construct fe5m2vec3";   break;
+    case EOpConstructFloatE5M2Vec4:  out.debug << "Construct fe5m2vec4";   break;
+    case EOpConstructFloatE4M3:  out.debug << "Construct floate4m3_t"; break;
+    case EOpConstructFloatE4M3Vec2:  out.debug << "Construct fe4m3vec2";   break;
+    case EOpConstructFloatE4M3Vec3:  out.debug << "Construct fe4m3vec3";   break;
+    case EOpConstructFloatE4M3Vec4:  out.debug << "Construct fe4m3vec4";   break;
     case EOpConstructFloat16:   out.debug << "Construct float16_t"; break;
     case EOpConstructF16Vec2:   out.debug << "Construct f16vec2";   break;
     case EOpConstructF16Vec3:   out.debug << "Construct f16vec3";   break;
@@ -811,6 +655,7 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpConstructReference:  out.debug << "Construct reference";  break;
     case EOpConstructCooperativeMatrixNV:  out.debug << "Construct cooperative matrix NV";  break;
     case EOpConstructCooperativeMatrixKHR:  out.debug << "Construct cooperative matrix KHR";  break;
+    case EOpConstructCooperativeVectorNV:  out.debug << "Construct cooperative vector NV";  break;
     case EOpConstructAccStruct: out.debug << "Construct acceleration structure"; break;
 
     case EOpLessThan:         out.debug << "Compare Less Than";             break;
@@ -835,6 +680,9 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
 
     case EOpDistance:      out.debug << "distance";                break;
     case EOpDot:           out.debug << "dot-product";             break;
+    case EOpDotPackedEXT:  out.debug << "dot-product-packed";break;
+    case EOpDotAccSatEXT:  out.debug << "dot-product-accumulate-saturate";break;
+    case EOpDotPackedAccSatEXT:  out.debug << "dot-product-packed-accumulate-saturate";break;
     case EOpCross:         out.debug << "cross-product";           break;
     case EOpFaceForward:   out.debug << "face-forward";            break;
     case EOpReflect:       out.debug << "reflect";                 break;
@@ -1107,13 +955,33 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpRayQueryGetIntersectionObjectToWorld:                          out.debug << "rayQueryGetIntersectionObjectToWorldEXT"; break;
     case EOpRayQueryGetIntersectionWorldToObject:                          out.debug << "rayQueryGetIntersectionWorldToObjectEXT"; break;
     case EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:             out.debug << "rayQueryGetIntersectionTriangleVertexPositionsEXT"; break;
+    case EOpRayQueryGetIntersectionClusterIdNV:                            out.debug << "rayQueryGetIntersectionClusterIdNV"; break;
+    case EOpRayQueryGetIntersectionSpherePositionNV:                       out.debug << "rayQueryGetIntersectionSpherePositionNV"; break;
+    case EOpRayQueryGetIntersectionSphereRadiusNV:                         out.debug << "rayQueryGetIntersectionSphereRadiusNV"; break;
+    case EOpRayQueryGetIntersectionLSSHitValueNV:                          out.debug << "rayQueryGetIntersectionLSSHitValueNV"; break;
+    case EOpRayQueryGetIntersectionLSSPositionsNV:                         out.debug << "rayQueryGetIntersectionLSSPositionsNV"; break;
+    case EOpRayQueryGetIntersectionLSSRadiiNV:                             out.debug << "rayQueryGetIntersectionLSSRadiiNV"; break;
+    case EOpRayQueryIsSphereHitNV:                                         out.debug << "rayQueryIsSphereHitNV"; break;
+    case EOpRayQueryIsLSSHitNV:                                            out.debug << "rayQueryIsLSSHitNV"; break;
 
     case EOpCooperativeMatrixLoad:  out.debug << "Load cooperative matrix KHR"; break;
     case EOpCooperativeMatrixStore:  out.debug << "Store cooperative matrix KHR"; break;
     case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices KHR"; break;
     case EOpCooperativeMatrixLoadNV:  out.debug << "Load cooperative matrix NV"; break;
     case EOpCooperativeMatrixStoreNV:  out.debug << "Store cooperative matrix NV"; break;
+    case EOpCooperativeMatrixLoadTensorNV:  out.debug << "Load cooperative matrix tensor NV"; break;
+    case EOpCooperativeMatrixStoreTensorNV:  out.debug << "Store cooperative matrix tensor NV"; break;
     case EOpCooperativeMatrixMulAddNV: out.debug << "MulAdd cooperative matrices NV"; break;
+    case EOpCooperativeMatrixReduceNV: out.debug << "Reduce cooperative matrices"; break;
+    case EOpCooperativeMatrixPerElementOpNV: out.debug << "cooperative matrix per element op"; break;
+    case EOpCooperativeMatrixTransposeNV: out.debug << "Transpose cooperative matrix"; break;
+
+    case EOpCooperativeVectorMatMulNV: out.debug << "Cooperative vector matrix multiply NV"; break;
+    case EOpCooperativeVectorMatMulAddNV: out.debug << "Cooperative vector matrix multiply add NV"; break;
+    case EOpCooperativeVectorLoadNV:  out.debug << "Load cooperative vector NV"; break;
+    case EOpCooperativeVectorStoreNV:  out.debug << "Store cooperative vector NV"; break;
+    case EOpCooperativeVectorOuterProductAccumulateNV: out.debug << "Cooperative vector outer product accumulate NV"; break;
+    case EOpCooperativeVectorReduceSumAccumulateNV: out.debug << "Cooperative vector reduce sum accumulate NV"; break;
 
     case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break;
     case EOpDebugPrintf:  out.debug << "Debug printf";  break;
@@ -1148,14 +1016,32 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpHitObjectGetCurrentTimeNV: out.debug << "HitObjectGetCurrentTimeNV"; break;
     case EOpHitObjectGetShaderBindingTableRecordIndexNV: out.debug << "HitObjectGetShaderBindingTableRecordIndexNV"; break;
     case EOpHitObjectGetShaderRecordBufferHandleNV: out.debug << "HitObjectReadShaderRecordBufferHandleNV"; break;
+    case EOpHitObjectGetClusterIdNV: out.debug << "HitObjectGetClusterIdNV"; break;
     case EOpReorderThreadNV: out.debug << "ReorderThreadNV"; break;
     case EOpFetchMicroTriangleVertexPositionNV: out.debug << "MicroTriangleVertexPositionNV"; break;
     case EOpFetchMicroTriangleVertexBarycentricNV: out.debug << "MicroTriangleVertexBarycentricNV"; break;
+    case EOpHitObjectGetSpherePositionNV: out.debug << "HitObjectGetSpherePositionNV"; break;
+    case EOpHitObjectGetSphereRadiusNV:   out.debug << "HitObjectGetSphereRadiusNV"; break;
+    case EOpHitObjectGetLSSPositionsNV:   out.debug << "HitObjectGetLSSPositionsNV"; break;
+    case EOpHitObjectGetLSSRadiiNV:       out.debug << "HitObjectGetLSSRadiiNV"; break;
+    case EOpHitObjectIsSphereHitNV:       out.debug << "HitObjectIsSphereHitNV"; break;
+    case EOpHitObjectIsLSSHitNV:          out.debug << "HitObjectIsLSSHitNV"; break;
 
     case EOpSpirvInst: out.debug << "spirv_instruction"; break;
     case EOpStencilAttachmentReadEXT: out.debug << "stencilAttachmentReadEXT"; break;
     case EOpDepthAttachmentReadEXT: out.debug << "depthAttachmentReadEXT"; break;
 
+    case EOpCreateTensorLayoutNV:           out.debug << "createTensorLayout"; break;
+    case EOpTensorLayoutSetBlockSizeNV:     out.debug << "setBlockSize"; break;
+    case EOpTensorLayoutSetDimensionNV:     out.debug << "setDimension"; break;
+    case EOpTensorLayoutSetStrideNV:        out.debug << "setStride"; break;
+    case EOpTensorLayoutSliceNV:            out.debug << "slice"; break;
+    case EOpTensorLayoutSetClampValueNV:    out.debug << "setClampValue"; break;
+    case EOpCreateTensorViewNV:             out.debug << "createTensorView"; break;
+    case EOpTensorViewSetDimensionNV:       out.debug << "setTensorViewDimensions"; break;
+    case EOpTensorViewSetStrideNV:          out.debug << "setTensorViewStride"; break;
+    case EOpTensorViewSetClipNV:            out.debug << "clipTensorView"; break;
+
     default: out.debug.message(EPrefixError, "Bad aggregation op");
     }
 
@@ -1285,6 +1171,9 @@ static void OutputConstantUnion(TInfoSink& out, const TIntermTyped* node, const
         case EbtFloat:
         case EbtDouble:
         case EbtFloat16:
+        case EbtBFloat16:
+        case EbtFloatE5M2:
+        case EbtFloatE4M3:
             OutputDouble(out, constUnion[i].getDConst(), extra);
             out.debug << "\n";
             break;
@@ -1568,6 +1457,8 @@ void TIntermediate::output(TInfoSink& infoSink, bool tree)
             infoSink.debug << "using non_coherent_depth_attachment_readEXT\n";
         if (nonCoherentStencilAttachmentReadEXT)
             infoSink.debug << "using non_coherent_stencil_attachment_readEXT\n";
+        if (nonCoherentTileAttachmentReadQCOM)
+            infoSink.debug << "using non_coherent_attachment_readQCOM\n";
         if (depthLayout != EldNone)
             infoSink.debug << "using " << TQualifier::getLayoutDepthString(depthLayout) << "\n";
         if (blendEquations != 0) {
@@ -1602,6 +1493,13 @@ void TIntermediate::output(TInfoSink& infoSink, bool tree)
                     localSizeSpecId[2] << ")\n";
             }
         }
+        if (nonCoherentTileAttachmentReadQCOM)
+            infoSink.debug << "using non_coherent_attachment_readQCOM\n";
+        if (isTileShadingRateQCOMSet()) {
+            infoSink.debug << "shading_rateQCOM = (" << tileShadingRateQCOM[0] << ", "
+                                                     << tileShadingRateQCOM[1] << ", "
+                                                     << tileShadingRateQCOM[2] << ")\n";
+        }
         break;
 
     default:

+ 142 - 5
src/libraries/glslang/glslang/MachineIndependent/iomapper.cpp

@@ -39,6 +39,7 @@
 
 #include "gl_types.h"
 #include "iomapper.h"
+#include "LiveTraverser.h"
 #include "SymbolTable.h"
 
 //
@@ -60,6 +61,108 @@
 
 namespace glslang {
 
+struct TVarEntryInfo {
+    long long id;
+    TIntermSymbol* symbol;
+    bool live;
+    TLayoutPacking upgradedToPushConstantPacking; // ElpNone means it hasn't been upgraded
+    int newBinding;
+    int newSet;
+    int newLocation;
+    int newComponent;
+    int newIndex;
+    EShLanguage stage;
+
+    void clearNewAssignments() {
+        upgradedToPushConstantPacking = ElpNone;
+        newBinding = -1;
+        newSet = -1;
+        newLocation = -1;
+        newComponent = -1;
+        newIndex = -1;
+    }
+
+    struct TOrderById {
+        inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) { return l.id < r.id; }
+    };
+
+    struct TOrderByPriority {
+        // ordering:
+        // 1) has both binding and set
+        // 2) has binding but no set
+        // 3) has no binding but set
+        // 4) has no binding and no set
+        inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) {
+            const TQualifier& lq = l.symbol->getQualifier();
+            const TQualifier& rq = r.symbol->getQualifier();
+
+            // simple rules:
+            // has binding gives 2 points
+            // has set gives 1 point
+            // who has the most points is more important.
+            int lPoints = (lq.hasBinding() ? 2 : 0) + (lq.hasSet() ? 1 : 0);
+            int rPoints = (rq.hasBinding() ? 2 : 0) + (rq.hasSet() ? 1 : 0);
+
+            if (lPoints == rPoints)
+                return l.id < r.id;
+            return lPoints > rPoints;
+        }
+    };
+
+    struct TOrderByPriorityAndLive {
+        // ordering:
+        // 1) do live variables first
+        // 2) has both binding and set
+        // 3) has binding but no set
+        // 4) has no binding but set
+        // 5) has no binding and no set
+        inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) {
+
+            const TQualifier& lq = l.symbol->getQualifier();
+            const TQualifier& rq = r.symbol->getQualifier();
+
+            // simple rules:
+            // has binding gives 2 points
+            // has set gives 1 point
+            // who has the most points is more important.
+            int lPoints = (lq.hasBinding() ? 2 : 0) + (lq.hasSet() ? 1 : 0);
+            int rPoints = (rq.hasBinding() ? 2 : 0) + (rq.hasSet() ? 1 : 0);
+
+            if (l.live != r.live)
+                return l.live > r.live;
+
+            if (lPoints != rPoints)
+                return lPoints > rPoints;
+
+            return l.id < r.id;
+        }
+    };
+};
+
+// override function "operator=", if a vector<const _Kty, _Ty> being sort,
+// when use vc++, the sort function will call :
+// pair& operator=(const pair<_Other1, _Other2>& _Right)
+// {
+//     first = _Right.first;
+//     second = _Right.second;
+//     return (*this);
+// }
+// that will make a const type handing on left.
+// override this function can avoid a compiler error.
+// In the future, if the vc++ compiler can handle such a situation,
+// this part of the code will be removed.
+struct TVarLivePair : std::pair<const TString, TVarEntryInfo> {
+    TVarLivePair(const std::pair<const TString, TVarEntryInfo>& _Right) : pair(_Right.first, _Right.second) {}
+    TVarLivePair& operator=(const TVarLivePair& _Right) {
+        const_cast<TString&>(first) = _Right.first;
+        second = _Right.second;
+        return (*this);
+    }
+    TVarLivePair(const TVarLivePair& src) : pair(src) { }
+};
+typedef std::vector<TVarLivePair> TVarLiveVector;
+
+
 class TVarGatherTraverser : public TLiveTraverser {
 public:
     TVarGatherTraverser(const TIntermediate& i, bool traverseDeadCode, TVarLiveMap& inList, TVarLiveMap& outList, TVarLiveMap& uniformList)
@@ -143,8 +246,11 @@ public:
             base->getWritableType().getQualifier().layoutComponent = at->second.newComponent;
         if (at->second.newIndex != -1)
             base->getWritableType().getQualifier().layoutIndex = at->second.newIndex;
-        if (at->second.upgradedToPushConstant)
+        if (at->second.upgradedToPushConstantPacking != ElpNone) {
             base->getWritableType().getQualifier().layoutPushConstant = true;
+            base->getWritableType().getQualifier().setBlockStorage(EbsPushConstant);
+            base->getWritableType().getQualifier().layoutPacking = at->second.upgradedToPushConstantPacking;
+        }
     }
 
   private:
@@ -176,7 +282,7 @@ struct TNotifyInOutAdaptor
 {
     EShLanguage stage;
     TIoMapResolver& resolver;
-    inline TNotifyInOutAdaptor(EShLanguage s, TIoMapResolver& r) 
+    inline TNotifyInOutAdaptor(EShLanguage s, TIoMapResolver& r)
       : stage(s)
       , resolver(r)
     {
@@ -1497,6 +1603,36 @@ bool TIoMapper::addStage(EShLanguage stage, TIntermediate& intermediate, TInfoSi
     return !hadError;
 }
 
+TGlslIoMapper::TGlslIoMapper() {
+    memset(inVarMaps,     0, sizeof(TVarLiveMap*)   * EShLangCount);
+    memset(outVarMaps,    0, sizeof(TVarLiveMap*)   * EShLangCount);
+    memset(uniformVarMap, 0, sizeof(TVarLiveMap*)   * EShLangCount);
+    memset(intermediates, 0, sizeof(TIntermediate*) * EShLangCount);
+    profile = ENoProfile;
+    version = 0;
+    autoPushConstantMaxSize = 128;
+    autoPushConstantBlockPacking = ElpStd430;
+}
+
+TGlslIoMapper::~TGlslIoMapper() {
+    for (size_t stage = 0; stage < EShLangCount; stage++) {
+        if (inVarMaps[stage] != nullptr) {
+            delete inVarMaps[stage];
+            inVarMaps[stage] = nullptr;
+        }
+        if (outVarMaps[stage] != nullptr) {
+            delete outVarMaps[stage];
+            outVarMaps[stage] = nullptr;
+        }
+        if (uniformVarMap[stage] != nullptr) {
+            delete uniformVarMap[stage];
+            uniformVarMap[stage] = nullptr;
+        }
+        if (intermediates[stage] != nullptr)
+            intermediates[stage] = nullptr;
+    }
+}
+
 // Map I/O variables to provided offsets, and make bindings for
 // unbound but live variables.
 //
@@ -1677,7 +1813,8 @@ bool TGlslIoMapper::doMap(TIoMapResolver* resolver, TInfoSink& infoSink) {
                 std::for_each(uniformVector.begin(), uniformVector.end(),
                                        [this](TVarLivePair& p) {
                 if (p.first == autoPushConstantBlockName) {
-                        p.second.upgradedToPushConstant = true;
+                        p.second.upgradedToPushConstantPacking = autoPushConstantBlockPacking;
+                        p.second.newSet = TQualifier::layoutSetEnd;
                     }
                 });
             }
@@ -1690,8 +1827,8 @@ bool TGlslIoMapper::doMap(TIoMapResolver* resolver, TInfoSink& infoSink) {
                 std::for_each(uniformVector.begin(), uniformVector.end(), [pUniformVarMap, stage](TVarLivePair p) {
                     auto at = pUniformVarMap[stage]->find(p.second.symbol->getAccessName());
                     if (at != pUniformVarMap[stage]->end() && at->second.id == p.second.id){
-                        if (p.second.upgradedToPushConstant) {
-                            at->second.upgradedToPushConstant = true;
+                        if (p.second.upgradedToPushConstantPacking != ElpNone) {
+                            at->second.upgradedToPushConstantPacking = p.second.upgradedToPushConstantPacking;
                         } else {
                             int resolvedBinding = at->second.newBinding;
                             at->second = p.second;

+ 7 - 143
src/libraries/glslang/glslang/MachineIndependent/iomapper.h

@@ -37,7 +37,6 @@
 #define _IOMAPPER_INCLUDED
 
 #include <cstdint>
-#include "LiveTraverser.h"
 #include <unordered_map>
 #include <unordered_set>
 //
@@ -49,84 +48,7 @@ class TInfoSink;
 namespace glslang {
 
 class TIntermediate;
-struct TVarEntryInfo {
-    long long id;
-    TIntermSymbol* symbol;
-    bool live;
-    bool upgradedToPushConstant;
-    int newBinding;
-    int newSet;
-    int newLocation;
-    int newComponent;
-    int newIndex;
-    EShLanguage stage;
-
-    void clearNewAssignments() {
-        upgradedToPushConstant = false;
-        newBinding = -1;
-        newSet = -1;
-        newLocation = -1;
-        newComponent = -1;
-        newIndex = -1;
-    }
-
-    struct TOrderById {
-        inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) { return l.id < r.id; }
-    };
-
-    struct TOrderByPriority {
-        // ordering:
-        // 1) has both binding and set
-        // 2) has binding but no set
-        // 3) has no binding but set
-        // 4) has no binding and no set
-        inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) {
-            const TQualifier& lq = l.symbol->getQualifier();
-            const TQualifier& rq = r.symbol->getQualifier();
-
-            // simple rules:
-            // has binding gives 2 points
-            // has set gives 1 point
-            // who has the most points is more important.
-            int lPoints = (lq.hasBinding() ? 2 : 0) + (lq.hasSet() ? 1 : 0);
-            int rPoints = (rq.hasBinding() ? 2 : 0) + (rq.hasSet() ? 1 : 0);
-
-            if (lPoints == rPoints)
-                return l.id < r.id;
-            return lPoints > rPoints;
-        }
-    };
-
-    struct TOrderByPriorityAndLive {
-        // ordering:
-        // 1) do live variables first
-        // 2) has both binding and set
-        // 3) has binding but no set
-        // 4) has no binding but set
-        // 5) has no binding and no set
-        inline bool operator()(const TVarEntryInfo& l, const TVarEntryInfo& r) {
-
-            const TQualifier& lq = l.symbol->getQualifier();
-            const TQualifier& rq = r.symbol->getQualifier();
-
-            // simple rules:
-            // has binding gives 2 points
-            // has set gives 1 point
-            // who has the most points is more important.
-            int lPoints = (lq.hasBinding() ? 2 : 0) + (lq.hasSet() ? 1 : 0);
-            int rPoints = (rq.hasBinding() ? 2 : 0) + (rq.hasSet() ? 1 : 0);
-
-            if (l.live != r.live)
-                return l.live > r.live;
-
-            if (lPoints != rPoints)
-                return lPoints > rPoints;
-
-            return l.id < r.id;
-        }
-    };
-};
-
+struct TVarEntryInfo;
 // Base class for shared TIoMapResolver services, used by several derivations.
 struct TDefaultIoResolverBase : public glslang::TIoMapResolver {
 public:
@@ -267,82 +189,22 @@ protected:
 
 typedef std::map<TString, TVarEntryInfo> TVarLiveMap;
 
-// override function "operator=", if a vector<const _Kty, _Ty> being sort,
-// when use vc++, the sort function will call :
-// pair& operator=(const pair<_Other1, _Other2>& _Right)
-// {
-//     first = _Right.first;
-//     second = _Right.second;
-//     return (*this);
-// }
-// that will make a const type handing on left.
-// override this function can avoid a compiler error.
-// In the future, if the vc++ compiler can handle such a situation,
-// this part of the code will be removed.
-struct TVarLivePair : std::pair<const TString, TVarEntryInfo> {
-    TVarLivePair(const std::pair<const TString, TVarEntryInfo>& _Right) : pair(_Right.first, _Right.second) {}
-    TVarLivePair& operator=(const TVarLivePair& _Right) {
-        const_cast<TString&>(first) = _Right.first;
-        second = _Right.second;
-        return (*this);
-    }
-    TVarLivePair(const TVarLivePair& src) : pair(src) { }
-};
-typedef std::vector<TVarLivePair> TVarLiveVector;
-
-// I/O mapper
-class TIoMapper {
-public:
-    TIoMapper() {}
-    virtual ~TIoMapper() {}
-    // grow the reflection stage by stage
-    bool virtual addStage(EShLanguage, TIntermediate&, TInfoSink&, TIoMapResolver*);
-    bool virtual doMap(TIoMapResolver*, TInfoSink&) { return true; }
-};
-
 // I/O mapper for GLSL
 class TGlslIoMapper : public TIoMapper {
 public:
-    TGlslIoMapper() {
-        memset(inVarMaps,     0, sizeof(TVarLiveMap*)   * (EShLangCount + 1));
-        memset(outVarMaps,    0, sizeof(TVarLiveMap*)   * (EShLangCount + 1));
-        memset(uniformVarMap, 0, sizeof(TVarLiveMap*)   * (EShLangCount + 1));
-        memset(intermediates, 0, sizeof(TIntermediate*) * (EShLangCount + 1));
-        profile = ENoProfile;
-        version = 0;
-        autoPushConstantMaxSize = 128;
-        autoPushConstantBlockPacking = ElpStd430;
-    }
-    virtual ~TGlslIoMapper() {
-        for (size_t stage = 0; stage < EShLangCount; stage++) {
-            if (inVarMaps[stage] != nullptr) {
-                delete inVarMaps[stage];
-                inVarMaps[stage] = nullptr;
-            }
-            if (outVarMaps[stage] != nullptr) {
-                delete outVarMaps[stage];
-                outVarMaps[stage] = nullptr;
-            }
-            if (uniformVarMap[stage] != nullptr) {
-                delete uniformVarMap[stage];
-                uniformVarMap[stage] = nullptr;
-            }
-            if (intermediates[stage] != nullptr)
-                intermediates[stage] = nullptr;
-        }
-    }
+    TGlslIoMapper();
+    virtual ~TGlslIoMapper();
     // If set, the uniform block with the given name will be changed to be backed by
     // push_constant if it's size is <= maxSize
-    void setAutoPushConstantBlock(const char* name, unsigned int maxSize, TLayoutPacking packing) {
+    bool setAutoPushConstantBlock(const char* name, unsigned int maxSize, TLayoutPacking packing) override {
         autoPushConstantBlockName = name;
         autoPushConstantMaxSize = maxSize;
         autoPushConstantBlockPacking = packing;
+        return true;
     }
     // grow the reflection stage by stage
     bool addStage(EShLanguage, TIntermediate&, TInfoSink&, TIoMapResolver*) override;
     bool doMap(TIoMapResolver*, TInfoSink&) override;
-    TVarLiveMap *inVarMaps[EShLangCount], *outVarMaps[EShLangCount],
-                *uniformVarMap[EShLangCount];
     TIntermediate* intermediates[EShLangCount];
     bool hadError = false;
     EProfile profile;
@@ -352,6 +214,8 @@ private:
     TString autoPushConstantBlockName;
     unsigned int autoPushConstantMaxSize;
     TLayoutPacking autoPushConstantBlockPacking;
+    TVarLiveMap *inVarMaps[EShLangCount], *outVarMaps[EShLangCount],
+                *uniformVarMap[EShLangCount];
 };
 
 } // end namespace glslang

+ 377 - 80
src/libraries/glslang/glslang/MachineIndependent/linkValidate.cpp

@@ -46,34 +46,46 @@
 // even if no merging was done (i.e., the stage was only one compilation unit).
 //
 
+#include "../../glslang/Public/ShaderLang.h"
 #include "localintermediate.h"
 #include "../Include/InfoSink.h"
 #include "SymbolTable.h"
+#include "LiveTraverser.h"
 
 namespace glslang {
 
 //
 // Link-time error emitter.
 //
-void TIntermediate::error(TInfoSink& infoSink, const char* message, EShLanguage unitStage)
+void TIntermediate::error(TInfoSink& infoSink, const TSourceLoc* loc, EShMessages messages, const char* message,
+                          EShLanguage unitStage)
 {
     infoSink.info.prefix(EPrefixError);
-    if (unitStage < EShLangCount)
-        infoSink.info << "Linking " << StageName(getStage()) << " and " << StageName(unitStage) << " stages: " << message << "\n";
-    else
+    if (loc)
+        infoSink.info.location(*loc, messages & EShMsgAbsolutePath, messages & EShMsgDisplayErrorColumn);
+    if (unitStage == EShLangCount)
         infoSink.info << "Linking " << StageName(language) << " stage: " << message << "\n";
+    else if (language == EShLangCount)
+        infoSink.info << "Linking " << StageName(unitStage) << " stage: " << message << "\n";
+    else
+        infoSink.info << "Linking " << StageName(language) << " and " << StageName(unitStage) << " stages: " << message << "\n";
 
     ++numErrors;
 }
 
 // Link-time warning.
-void TIntermediate::warn(TInfoSink& infoSink, const char* message, EShLanguage unitStage)
+void TIntermediate::warn(TInfoSink& infoSink, const TSourceLoc* loc, EShMessages messages, const char* message,
+                         EShLanguage unitStage)
 {
     infoSink.info.prefix(EPrefixWarning);
-    if (unitStage < EShLangCount)
-        infoSink.info << "Linking " << StageName(language) << " and " << StageName(unitStage) << " stages: " << message << "\n";
-    else
+    if (loc)
+        infoSink.info.location(*loc, messages & EShMsgAbsolutePath, messages & EShMsgDisplayErrorColumn);
+    if (unitStage == EShLangCount)
         infoSink.info << "Linking " << StageName(language) << " stage: " << message << "\n";
+    else if (language == EShLangCount)
+        infoSink.info << "Linking " << StageName(unitStage) << " stage: " << message << "\n";
+    else
+        infoSink.info << "Linking " << StageName(language) << " and " << StageName(unitStage) << " stages: " << message << "\n";
 }
 
 // TODO: 4.4 offset/align:  "Two blocks linked together in the same program with the same block
@@ -113,7 +125,9 @@ void TIntermediate::mergeUniformObjects(TInfoSink& infoSink, TIntermediate& unit
     mergeLinkerObjects(infoSink, linkerObjects, unitLinkerObjects, unit.getStage());
 }
 
-static inline bool isSameInterface(TIntermSymbol* symbol, EShLanguage stage, TIntermSymbol* unitSymbol, EShLanguage unitStage) {
+static inline bool isSameInterface(TIntermSymbol* symbol, TIntermSymbol* unitSymbol) {
+    EShLanguage stage = symbol->getStage();
+    EShLanguage unitStage = unitSymbol->getStage();
     return // 1) same stage and same shader interface
         (stage == unitStage && symbol->getType().getShaderInterface() == unitSymbol->getType().getShaderInterface()) ||
         // 2) accross stages and both are uniform or buffer
@@ -124,21 +138,54 @@ static inline bool isSameInterface(TIntermSymbol* symbol, EShLanguage stage, TIn
         (unitStage < stage && symbol->getQualifier().storage == EvqVaryingIn && unitSymbol->getQualifier().storage == EvqVaryingOut);
 }
 
-static bool isSameSymbol(TIntermSymbol* symbol1, EShLanguage stage1, TIntermSymbol* symbol2, EShLanguage stage2) {
+static bool isSameSymbol(TIntermSymbol* symbol1, TIntermSymbol* symbol2) {
     // If they are both blocks in the same shader interface,
     // match by the block-name, not the identifier name.
     if (symbol1->getType().getBasicType() == EbtBlock && symbol2->getType().getBasicType() == EbtBlock) {
-        if (isSameInterface(symbol1, stage1, symbol2, stage2)) {
+        if (isSameInterface(symbol1, symbol2)) {
             return symbol1->getType().getTypeName() == symbol2->getType().getTypeName();
         }
     } else if (symbol1->getName() == symbol2->getName())
         return true;
     return false;
 }
+
+//
+// merge implicit array sizes for uniform/buffer objects
+//
+void TIntermediate::mergeImplicitArraySizes(TInfoSink&, TIntermediate& unit) {
+    if (unit.treeRoot == nullptr || treeRoot == nullptr)
+        return;
+
+    // Get the linker-object lists
+    TIntermSequence& linkerObjects = findLinkerObjects()->getSequence();
+    TIntermSequence unitLinkerObjects = unit.findLinkerObjects()->getSequence();
+
+    // filter unitLinkerObjects to only contain uniforms
+    auto end = std::remove_if(unitLinkerObjects.begin(), unitLinkerObjects.end(),
+        [](TIntermNode* node) {return node->getAsSymbolNode()->getQualifier().storage != EvqUniform &&
+                                      node->getAsSymbolNode()->getQualifier().storage != EvqBuffer; });
+    unitLinkerObjects.resize(end - unitLinkerObjects.begin());
+
+    std::size_t initialNumLinkerObjects = linkerObjects.size();
+    for (unsigned int unitLinkObj = 0; unitLinkObj < unitLinkerObjects.size(); ++unitLinkObj) {
+        for (std::size_t linkObj = 0; linkObj < initialNumLinkerObjects; ++linkObj) {
+            TIntermSymbol* symbol = linkerObjects[linkObj]->getAsSymbolNode();
+            TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode();
+            assert(symbol && unitSymbol);
+
+            if (isSameSymbol(symbol, unitSymbol)) {
+                // Update implicit array sizes
+                mergeImplicitArraySizes(symbol->getWritableType(), unitSymbol->getType());
+            }
+        }
+    }
+}
+
 //
 // do error checking on the shader boundary in / out vars
 //
-void TIntermediate::checkStageIO(EShMessages messages, TInfoSink& infoSink, TIntermediate& unit) {
+void TIntermediate::checkStageIO(TInfoSink& infoSink, TIntermediate& unit, EShMessages messages) {
     if (unit.treeRoot == nullptr || treeRoot == nullptr)
         return;
 
@@ -159,32 +206,272 @@ void TIntermediate::checkStageIO(EShMessages messages, TInfoSink& infoSink, TInt
     // do matching and error checking
     mergeLinkerObjects(infoSink, linkerObjects, unitLinkerObjects, unit.getStage());
 
-    // Check that all of our inputs have matching outputs from the previous stage.
-    // Only do this for Vulkan, since GL_ARB_separate_shader_objects allows for
-    // the in/out to not match
-    if (spvVersion.vulkan > 0 || (messages & EshMsgCrossStageIO)) {
-        for (auto& nextStageInterm : unitLinkerObjects) {
-            auto* nextStageSymbol = nextStageInterm->getAsSymbolNode();
-            bool found = false;
-            for (auto& curStageInterm : linkerObjects) {
-                if (isSameSymbol(curStageInterm->getAsSymbolNode(), getStage(), nextStageSymbol, unit.getStage())) {
-                    found = true;
-                    break;
+    if ((messages & EShMsgValidateCrossStageIO) == 0)
+        return;
+
+    // The OpenGL Shading Language, Version 4.60.8 (https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.pdf)
+    // 4.3.4 Input Variables
+    // Only the input variables that are statically read need to be written by the previous stage; it is
+    // allowed to have superfluous declarations of input variables. This is shown in the following table.
+    // +------------------------------------------------------------------------------------------------+
+    // | Treatment of Mismatched Input        | Consuming Shader (input variables)                      |
+    // | Variables                            |---------------------------------------------------------|
+    // |                                      | No          | Declared but no | Declared and Static Use |
+    // |                                      | Declaration | Static Use      |                         |
+    // |--------------------------------------+-------------+-----------------+-------------------------|
+    // | Generating Shader  | No Declaration  | Allowed     | Allowed         | Link-Time Error         |
+    // | (output variables) |-----------------+-------------+-----------------+-------------------------|
+    // |                    | Declared but no | Allowed     | Allowed         | Allowed (values are     |
+    // |                    | Static Use      |             |                 | undefined)              |
+    // |                    |-----------------+-------------+-----------------+-------------------------|
+    // |                    | Declared and    | Allowed     | Allowed         | Allowed (values are     |
+    // |                    | Static Use      |             |                 | potentially undefined)  |
+    // +------------------------------------------------------------------------------------------------+
+    // Consumption errors are based on static use only. Compilation may generate a warning, but not an
+    // error, for any dynamic use the compiler can deduce that might cause consumption of undefined values.
+
+    // TODO: implement support for geometry passthrough
+    if (getGeoPassthroughEXT()) {
+        unit.warn(infoSink, "GL_NV_geometry_shader_passthrough is enabled, skipping cross-stage IO validation",
+                  getStage());
+        return;
+    }
+
+    class TIOTraverser : public TLiveTraverser {
+    public:
+        TIOTraverser(TIntermediate& i, bool all, TIntermSequence& sequence, TStorageQualifier storage)
+            : TLiveTraverser(i, all, true, false, false), sequence(sequence), storage(storage)
+        {
+        }
+
+        virtual void visitSymbol(TIntermSymbol* symbol)
+        {
+            if (symbol->getQualifier().storage == storage)
+                sequence.push_back(symbol);
+        }
+
+    private:
+        TIntermSequence& sequence;
+        TStorageQualifier storage;
+    };
+
+    // live symbols only
+    TIntermSequence unitLiveInputs;
+
+    TIOTraverser unitTraverser(unit, false, unitLiveInputs, EvqVaryingIn);
+    unitTraverser.pushFunction(unit.getEntryPointMangledName().c_str());
+    while (! unitTraverser.destinations.empty()) {
+        TIntermNode* destination = unitTraverser.destinations.back();
+        unitTraverser.destinations.pop_back();
+        destination->traverse(&unitTraverser);
+    }
+
+    // all symbols
+    TIntermSequence allOutputs;
+
+    TIOTraverser traverser(*this, true, allOutputs, EvqVaryingOut);
+    getTreeRoot()->traverse(&traverser);
+
+    std::unordered_set<int> outputLocations;
+    for (auto& output : allOutputs) {
+        if (output->getAsSymbolNode()->getBasicType() == EbtBlock) {
+            int lastLocation = -1;
+            if (output->getAsSymbolNode()->getQualifier().hasLocation())
+                lastLocation = output->getAsSymbolNode()->getQualifier().layoutLocation;
+            const TTypeList* members = output->getAsSymbolNode()->getType().getStruct();
+            for (auto& member : *members) {
+                int location = lastLocation;
+                if (member.type->getQualifier().hasLocation())
+                    location = member.type->getQualifier().layoutLocation;
+                if (location != -1) {
+                    int locationSize = TIntermediate::computeTypeLocationSize(*member.type, getStage());
+                    for (int i = 0; i < locationSize; ++i)
+                        outputLocations.insert(location + i);
+                    lastLocation = location + locationSize;
                 }
             }
-            if (!found) {
-                TString errmsg;
-                errmsg.append("Input '");
-                if (nextStageSymbol->getType().getBasicType() == EbtBlock)
-                    errmsg.append(nextStageSymbol->getType().getTypeName());
-                else
-                    errmsg.append(nextStageSymbol->getName());
-                errmsg.append("' in ").append(StageName(unit.getStage()));
-                errmsg.append(" shader has no corresponding output in ").append(StageName(getStage())).append(" shader.");
-                error(infoSink, errmsg.c_str(), unit.getStage());
-            }
+        } else {
+            int locationSize = TIntermediate::computeTypeLocationSize(output->getAsSymbolNode()->getType(), getStage());
+            for (int i = 0; i < locationSize; ++i)
+                outputLocations.insert(output->getAsSymbolNode()->getQualifier().layoutLocation + i);
         }
     }
+
+    // remove unitStage inputs with matching outputs in the current stage
+    auto liveEnd = std::remove_if(
+        unitLiveInputs.begin(), unitLiveInputs.end(), [this, &allOutputs, &outputLocations](TIntermNode* input) {
+            // ignore built-ins
+            if (input->getAsSymbolNode()->getAccessName().compare(0, 3, "gl_") == 0)
+                return true;
+            // try to match by location
+            if (input->getAsSymbolNode()->getQualifier().hasLocation() &&
+                outputLocations.find(input->getAsSymbolNode()->getQualifier().layoutLocation) != outputLocations.end())
+                return true;
+            if (input->getAsSymbolNode()->getBasicType() == EbtBlock) {
+                int lastLocation = -1;
+                if (input->getAsSymbolNode()->getQualifier().hasLocation())
+                    lastLocation = input->getAsSymbolNode()->getQualifier().layoutLocation;
+                const TTypeList* members = input->getAsSymbolNode()->getType().getStruct();
+                for (auto& member : *members) {
+                    int location = lastLocation;
+                    if (member.type->getQualifier().hasLocation())
+                        location = member.type->getQualifier().layoutLocation;
+                    if (location != -1) {
+                        int locationSize = TIntermediate::computeTypeLocationSize(*member.type, getStage());
+                        for (int i = 0; i < locationSize; ++i)
+                            if (outputLocations.find(location + i) != outputLocations.end())
+                                return true;
+                        lastLocation = location + locationSize;
+                    }
+                }
+            }
+            // otherwise, try to match by name
+            return std::any_of(allOutputs.begin(), allOutputs.end(), [input](TIntermNode* output) {
+                return output->getAsSymbolNode()->getAccessName() == input->getAsSymbolNode()->getAccessName();
+            });
+        });
+    unitLiveInputs.resize(liveEnd - unitLiveInputs.begin());
+
+    // check remaining loose unitStage inputs for a matching output block member
+    liveEnd = std::remove_if(unitLiveInputs.begin(), unitLiveInputs.end(), [&allOutputs](TIntermNode* input) {
+        return std::any_of(allOutputs.begin(), allOutputs.end(), [input](TIntermNode* output) {
+            if (output->getAsSymbolNode()->getBasicType() != EbtBlock)
+                return false;
+            const TTypeList* members = output->getAsSymbolNode()->getType().getStruct();
+            return std::any_of(members->begin(), members->end(), [input](TTypeLoc type) {
+                return type.type->getFieldName() == input->getAsSymbolNode()->getName();
+            });
+        });
+    });
+    unitLiveInputs.resize(liveEnd - unitLiveInputs.begin());
+
+    // finally, check remaining unitStage block inputs for a matching loose output
+    liveEnd = std::remove_if(
+        unitLiveInputs.begin(), unitLiveInputs.end(), [&allOutputs](TIntermNode* input) {
+            if (input->getAsSymbolNode()->getBasicType() != EbtBlock)
+                return false;
+            // liveness isn't tracked per member so finding any one live member is the best we can do
+            const TTypeList* members = input->getAsSymbolNode()->getType().getStruct();
+            return std::any_of(members->begin(), members->end(), [allOutputs](TTypeLoc type) {
+                return std::any_of(allOutputs.begin(), allOutputs.end(), [&type](TIntermNode* output) {
+                    return type.type->getFieldName() == output->getAsSymbolNode()->getName();
+                });
+            });
+        });
+    unitLiveInputs.resize(liveEnd - unitLiveInputs.begin());
+
+    // any remaining unitStage inputs have no matching output
+    std::for_each(unitLiveInputs.begin(), unitLiveInputs.end(), [&](TIntermNode* input) {
+        unit.error(infoSink, &input->getLoc(), messages,
+                   "Preceding stage has no matching declaration for statically used input:", getStage());
+        infoSink.info << "    "
+                      << input->getAsSymbolNode()->getType().getCompleteString(
+                             true, true, false, true, input->getAsSymbolNode()->getAccessName())
+                      << "\n";
+    });
+
+    // TODO: warn about statically read inputs with outputs declared but not written to
+}
+
+void TIntermediate::optimizeStageIO(TInfoSink&, TIntermediate& unit)
+{
+    // don't do any input/output demotion on compute, raytracing, or task/mesh stages
+    // TODO: support task/mesh
+    if (getStage() > EShLangFragment || unit.getStage() > EShLangFragment) {
+        return;
+    }
+
+    class TIOTraverser : public TLiveTraverser {
+    public:
+        TIOTraverser(TIntermediate& i, bool all, TIntermSequence& sequence, TStorageQualifier storage)
+            : TLiveTraverser(i, all, true, false, false), sequence(sequence), storage(storage)
+        {
+        }
+
+        virtual void visitSymbol(TIntermSymbol* symbol)
+        {
+            if (symbol->getQualifier().storage == storage) {
+                sequence.push_back(symbol);
+            }
+        }
+
+    private:
+        TIntermSequence& sequence;
+        TStorageQualifier storage;
+    };
+
+    // live symbols only
+    TIntermSequence unitLiveInputs;
+
+    TIOTraverser unitTraverser(unit, false, unitLiveInputs, EvqVaryingIn);
+    unitTraverser.pushFunction(unit.getEntryPointMangledName().c_str());
+    while (! unitTraverser.destinations.empty()) {
+        TIntermNode* destination = unitTraverser.destinations.back();
+        unitTraverser.destinations.pop_back();
+        destination->traverse(&unitTraverser);
+    }
+
+    TIntermSequence allOutputs;
+    TIntermSequence unitAllInputs;
+
+    TIOTraverser allTraverser(*this, true, allOutputs, EvqVaryingOut);
+    getTreeRoot()->traverse(&allTraverser);
+
+    TIOTraverser unitAllTraverser(unit, true, unitAllInputs, EvqVaryingIn);
+    unit.getTreeRoot()->traverse(&unitAllTraverser);
+
+    // find outputs not consumed by the next stage
+    std::for_each(allOutputs.begin(), allOutputs.end(), [&unitLiveInputs, &unitAllInputs](TIntermNode* output) {
+        // don't do anything to builtins
+        if (output->getAsSymbolNode()->getAccessName().compare(0, 3, "gl_") == 0)
+            return;
+
+        // don't demote block outputs (for now)
+        if (output->getAsSymbolNode()->getBasicType() == EbtBlock)
+            return;
+
+        // check if the (loose) output has a matching loose input
+        auto isMatchingInput = [output](TIntermNode* input) {
+            return output->getAsSymbolNode()->getAccessName() == input->getAsSymbolNode()->getAccessName();
+        };
+
+        // check if the (loose) output has a matching block member input
+        auto isMatchingInputBlockMember = [output](TIntermNode* input) {
+            // ignore loose inputs
+            if (input->getAsSymbolNode()->getBasicType() != EbtBlock)
+                return false;
+
+            // don't demote loose outputs with matching input block members
+            auto isMatchingBlockMember = [output](TTypeLoc type) {
+                return type.type->getFieldName() == output->getAsSymbolNode()->getName();
+            };
+            const TTypeList* members = input->getAsSymbolNode()->getType().getStruct();
+            return std::any_of(members->begin(), members->end(), isMatchingBlockMember);
+        };
+
+        // determine if the input/output pair should be demoted
+        // do the faster (and more likely) loose-loose check first
+        if (std::none_of(unitLiveInputs.begin(), unitLiveInputs.end(), isMatchingInput) && 
+            std::none_of(unitAllInputs.begin(), unitAllInputs.end(), isMatchingInputBlockMember)) {
+            // demote any input matching the output
+            auto demoteMatchingInputs = [output](TIntermNode* input) {
+                if (output->getAsSymbolNode()->getAccessName() == input->getAsSymbolNode()->getAccessName()) {
+                    // demote input to a plain variable
+                    TIntermSymbol* symbol = input->getAsSymbolNode();
+                    symbol->getQualifier().storage = EvqGlobal;
+                    symbol->getQualifier().clearInterstage();
+                    symbol->getQualifier().clearLayout();
+                }
+            };
+
+            // demote all matching outputs to a plain variable
+            TIntermSymbol* symbol = output->getAsSymbolNode();
+            symbol->getQualifier().storage = EvqGlobal;
+            symbol->getQualifier().clearInterstage();
+            symbol->getQualifier().clearLayout();
+            std::for_each(unitAllInputs.begin(), unitAllInputs.end(), demoteMatchingInputs);
+        }
+    });
 }
 
 void TIntermediate::mergeCallGraphs(TInfoSink& infoSink, TIntermediate& unit)
@@ -313,6 +600,7 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit)
     MERGE_TRUE(nonCoherentColorAttachmentReadEXT);
     MERGE_TRUE(nonCoherentDepthAttachmentReadEXT);
     MERGE_TRUE(nonCoherentStencilAttachmentReadEXT);
+    MERGE_TRUE(nonCoherentTileAttachmentReadQCOM);
 
     if (depthLayout == EldNone)
         depthLayout = unit.depthLayout;
@@ -647,10 +935,10 @@ void TIntermediate::mergeBlockDefinitions(TInfoSink& infoSink, TIntermSymbol* bl
                 // don't need as many checks as when merging symbols, since
                 // initializers and most qualifiers are stripped when the member is moved into the block
                 if ((*memberType) != (*unitMemberType)) {
-                    error(infoSink, "Types must match:");
+                    error(infoSink, "Types must match:", unitBlock->getStage());
                     infoSink.info << "    " << memberType->getFieldName() << ": ";
-                    infoSink.info << "\"" << memberType->getCompleteString() << "\" versus ";
-                    infoSink.info << "\"" << unitMemberType->getCompleteString() << "\"\n";
+                    infoSink.info << "\"" << memberType->getCompleteString() << "\" in stage " << StageName(block->getStage()) << " versus ";
+                    infoSink.info << "\"" << unitMemberType->getCompleteString() << "\" in stage " << StageName(unitBlock->getStage()) << "\n";
                 }
 
                 memberIndexUpdates[i] = j;
@@ -743,18 +1031,13 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
     // Error check and merge the linker objects (duplicates should not be created)
     std::size_t initialNumLinkerObjects = linkerObjects.size();
     for (unsigned int unitLinkObj = 0; unitLinkObj < unitLinkerObjects.size(); ++unitLinkObj) {
-        TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode();
         bool merge = true;
-
-        // Don't merge inputs backwards into previous stages
-        if (getStage() != unitStage && unitSymbol->getQualifier().storage == EvqVaryingIn)
-            merge = false;
-
         for (std::size_t linkObj = 0; linkObj < initialNumLinkerObjects; ++linkObj) {
             TIntermSymbol* symbol = linkerObjects[linkObj]->getAsSymbolNode();
+            TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode();
             assert(symbol && unitSymbol);
 
-            if (isSameSymbol(symbol, getStage(), unitSymbol, unitStage)) {
+            if (isSameSymbol(symbol, unitSymbol)) {
                 // filter out copy
                 merge = false;
 
@@ -780,18 +1063,39 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
                 }
                 else if (symbol->getWritableType().isImplicitlySizedArray() && unitSymbol->getType().isSizedArray()) {
                     if (symbol->getWritableType().getImplicitArraySize() > unitSymbol->getType().getOuterArraySize())
-                        error(infoSink, "Implicit size of unsized array doesn't match same symbol among multiple shaders.");
+                        error(infoSink, "Implicit size of unsized array doesn't match same symbol among multiple shaders.", unitStage);
                 }
                 else if (unitSymbol->getType().isImplicitlySizedArray() && symbol->getWritableType().isSizedArray()) {
                     if (unitSymbol->getType().getImplicitArraySize() > symbol->getWritableType().getOuterArraySize())
-                        error(infoSink, "Implicit size of unsized array doesn't match same symbol among multiple shaders.");
+                        error(infoSink, "Implicit size of unsized array doesn't match same symbol among multiple shaders.", unitStage);
+                }
+
+                if (symbol->getType().isStruct() && unitSymbol->getType().isStruct() &&
+                    symbol->getType().getStruct()->size() == unitSymbol->getType().getStruct()->size()) {
+                    for (int i = 0; i < (int)symbol->getType().getStruct()->size(); ++i) {
+                        auto& type = (*symbol->getWritableType().getStruct())[i];
+                        auto& unitType = (*unitSymbol->getWritableType().getStruct())[i];
+
+                        if (type.type->isImplicitlySizedArray() && unitType.type->isImplicitlySizedArray()) {
+                            if (unitType.type->getImplicitArraySize() > type.type->getImplicitArraySize())
+                                type.type->updateImplicitArraySize(unitType.type->getImplicitArraySize());
+                        }
+                        else if (type.type->isImplicitlySizedArray() && unitType.type->isSizedArray()) {
+                            if (type.type->getImplicitArraySize() > unitType.type->getOuterArraySize())
+                                error(infoSink, "Implicit size of unsized array doesn't match same symbol among multiple shaders.", unitStage);
+                        }
+                        else if (type.type->isSizedArray() && unitType.type->isImplicitlySizedArray()) {
+                            if (type.type->getOuterArraySize() < unitType.type->getImplicitArraySize())
+                                error(infoSink, "Implicit size of unsized array doesn't match same symbol among multiple shaders.", unitStage);
+                        }
+                    }
                 }
 
                 // Update implicit array sizes
                 mergeImplicitArraySizes(symbol->getWritableType(), unitSymbol->getType());
 
                 // Check for consistent types/qualification/initializers etc.
-                mergeErrorCheck(infoSink, *symbol, *unitSymbol, unitStage);
+                mergeErrorCheck(infoSink, *symbol, *unitSymbol);
             }
             // If different symbols, verify they arn't push_constant since there can only be one per stage
             else if (symbol->getQualifier().isPushConstant() && unitSymbol->getQualifier().isPushConstant() && getStage() == unitStage)
@@ -833,7 +1137,7 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
                         }
                     };
 
-                    if (isSameInterface(symbol, getStage(), unitSymbol, unitStage)) {
+                    if (isSameInterface(symbol, unitSymbol)) {
                         checkName(symbol->getName());
 
                         // check members of other anonymous blocks
@@ -877,9 +1181,11 @@ void TIntermediate::mergeImplicitArraySizes(TType& type, const TType& unitType)
 //
 // This function only does one of intra- or cross-stage matching per call.
 //
-void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& symbol, const TIntermSymbol& unitSymbol, EShLanguage unitStage)
+void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& symbol, const TIntermSymbol& unitSymbol)
 {
-    bool crossStage = getStage() != unitStage;
+    EShLanguage stage = symbol.getStage();
+    EShLanguage unitStage = unitSymbol.getStage();
+    bool crossStage = stage != unitStage;
     bool writeTypeComparison = false;
     bool errorReported = false;
     bool printQualifiers = false;
@@ -891,10 +1197,10 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
         // but, we make an exception if one is an implicit array and the other is sized
         // or if the array sizes differ because of the extra array dimension on some in/out boundaries
         bool arraysMatch = false;
-        if (isIoResizeArray(symbol.getType(), getStage()) || isIoResizeArray(unitSymbol.getType(), unitStage)) {
+        if (isIoResizeArray(symbol.getType(), stage) || isIoResizeArray(unitSymbol.getType(), unitStage)) {
             // if the arrays have an extra dimension because of the stage.
             // compare dimensions while ignoring the outer dimension
-            unsigned int firstDim = isIoResizeArray(symbol.getType(), getStage()) ? 1 : 0;
+            unsigned int firstDim = isIoResizeArray(symbol.getType(), stage) ? 1 : 0;
             unsigned int numDim = symbol.getArraySizes()
                 ? symbol.getArraySizes()->getNumDims() : 0;
             unsigned int unitFirstDim = isIoResizeArray(unitSymbol.getType(), unitStage) ? 1 : 0;
@@ -923,7 +1229,7 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
             if (lpidx >= 0 && rpidx >= 0) {
                 error(infoSink, "Member names and types must match:", unitStage);
                 infoSink.info << "    Block: " << symbol.getType().getTypeName() << "\n";
-                infoSink.info << "        " << StageName(getStage()) << " stage: \""
+                infoSink.info << "        " << StageName(stage) << " stage: \""
                               << (*symbol.getType().getStruct())[lpidx].type->getCompleteString(true, false, false, true,
                                       (*symbol.getType().getStruct())[lpidx].type->getFieldName()) << "\"\n";
                 infoSink.info << "        " << StageName(unitStage) << " stage: \""
@@ -931,20 +1237,20 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
                                       (*unitSymbol.getType().getStruct())[rpidx].type->getFieldName()) << "\"\n";
                 errorReported = true;
             } else if (lpidx >= 0 && rpidx == -1) {
-                  TString errmsg = StageName(getStage());
+                  TString errmsg = StageName(stage);
                   errmsg.append(" block member has no corresponding member in ").append(StageName(unitStage)).append(" block:");
                   error(infoSink, errmsg.c_str(), unitStage);
-                  infoSink.info << "    " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: "
+                  infoSink.info << "    " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: "
                     << (*symbol.getType().getStruct())[lpidx].type->getFieldName() << "\n";
                   infoSink.info << "    " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << ", Member: n/a \n";
                   errorReported = true;
             } else if (lpidx == -1 && rpidx >= 0) {
                   TString errmsg = StageName(unitStage);
-                  errmsg.append(" block member has no corresponding member in ").append(StageName(getStage())).append(" block:");
+                  errmsg.append(" block member has no corresponding member in ").append(StageName(stage)).append(" block:");
                   error(infoSink, errmsg.c_str(), unitStage);
                   infoSink.info << "    " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << ", Member: "
                     << (*unitSymbol.getType().getStruct())[rpidx].type->getFieldName() << "\n";
-                  infoSink.info << "    " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: n/a \n";
+                  infoSink.info << "    " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: n/a \n";
                   errorReported = true;
             } else {
                   error(infoSink, "Types must match:", unitStage);
@@ -1001,7 +1307,7 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
                 layoutQualifierError = true;
             }
             if (layoutQualifierError) {
-                infoSink.info << "    " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: "
+                infoSink.info << "    " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << ", Member: "
                               << (*symbol.getType().getStruct())[li].type->getFieldName() << " \""
                               << (*symbol.getType().getStruct())[li].type->getCompleteString(true, true, false, false) << "\"\n";
                 infoSink.info << "    " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << ", Member: "
@@ -1113,6 +1419,10 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
         error(infoSink, "Memory volatil qualifier must match:", unitStage);
         memoryQualifierError = true;
     }
+    if (symbol.getQualifier().nontemporal != unitSymbol.getQualifier().nontemporal) {
+        error(infoSink, "Memory nontemporal qualifier must match:", unitStage);
+        memoryQualifierError = true;
+    }
     if (symbol.getQualifier().restrict != unitSymbol.getQualifier().restrict) {
         error(infoSink, "Memory restrict qualifier must match:", unitStage);
         memoryQualifierError = true;
@@ -1182,24 +1492,24 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
         if (symbol.getType().getBasicType() == EbtBlock && unitSymbol.getType().getBasicType() == EbtBlock &&
             symbol.getType().getStruct() && unitSymbol.getType().getStruct()) {
           if (printType) {
-            infoSink.info << "    " << StageName(getStage()) << " stage: \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision,
+            infoSink.info << "    " << StageName(stage) << " stage: \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision,
                                                     printType, symbol.getName(), symbol.getType().getTypeName()) << "\"\n";
             infoSink.info << "    " << StageName(unitStage) << " stage: \"" << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision,
                                                     printType, unitSymbol.getName(), unitSymbol.getType().getTypeName()) << "\"\n";
           } else {
-            infoSink.info << "    " << StageName(getStage()) << " stage: Block: " << symbol.getType().getTypeName() << " Instance: " << symbol.getName()
+            infoSink.info << "    " << StageName(stage) << " stage: Block: " << symbol.getType().getTypeName() << " Instance: " << symbol.getName()
               << ": \"" << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n";
             infoSink.info << "    " << StageName(unitStage) << " stage: Block: " << unitSymbol.getType().getTypeName() << " Instance: " << unitSymbol.getName()
               << ": \"" << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n";
           }
         } else {
           if (printType) {
-            infoSink.info << "    " << StageName(getStage()) << " stage: \""
+            infoSink.info << "    " << StageName(stage) << " stage: \""
               << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType, symbol.getName()) << "\"\n";
             infoSink.info << "    " << StageName(unitStage) << " stage: \""
               << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType, unitSymbol.getName()) << "\"\n";
           } else {
-            infoSink.info << "    " << StageName(getStage()) << " stage: " << symbol.getName() << " \""
+            infoSink.info << "    " << StageName(stage) << " stage: " << symbol.getName() << " \""
               << symbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n";
             infoSink.info << "    " << StageName(unitStage) << " stage: " << unitSymbol.getName() << " \""
               << unitSymbol.getType().getCompleteString(true, printQualifiers, printPrecision, printType) << "\"\n";
@@ -1231,7 +1541,8 @@ void TIntermediate::sharedBlockCheck(TInfoSink& infoSink)
 // Do final link-time error checking of a complete (merged) intermediate representation.
 // (Much error checking was done during merging).
 //
-// Also, lock in defaults of things not set, including array sizes.
+// Also, lock in defaults of things not set.
+// Defer adopting implicit array sizes to later, after all stages are merged.
 //
 void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled)
 {
@@ -1392,23 +1703,6 @@ void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled)
         error(infoSink, "Unknown Stage.");
         break;
     }
-
-    // Process the tree for any node-specific work.
-    class TFinalLinkTraverser : public TIntermTraverser {
-    public:
-        TFinalLinkTraverser() { }
-        virtual ~TFinalLinkTraverser() { }
-
-        virtual void visitSymbol(TIntermSymbol* symbol)
-        {
-            // Implicitly size arrays.
-            // If an unsized array is left as unsized, it effectively
-            // becomes run-time sized.
-            symbol->getWritableType().adoptImplicitArraySizes(false);
-        }
-    } finalLinkTraverser;
-
-    treeRoot->traverse(&finalLinkTraverser);
 }
 
 //
@@ -2091,6 +2385,9 @@ int TIntermediate::getBaseAlignmentScalar(const TType& type, int& size)
     case EbtUint64:
     case EbtDouble:  size = 8; return 8;
     case EbtFloat16: size = 2; return 2;
+    case EbtBFloat16: size = 2; return 2;
+    case EbtFloatE5M2:
+    case EbtFloatE4M3:
     case EbtInt8:
     case EbtUint8:   size = 1; return 1;
     case EbtInt16:

+ 54 - 10
src/libraries/glslang/glslang/MachineIndependent/localintermediate.h

@@ -268,6 +268,7 @@ public:
         gpu_shader_fp64                           = 1 << 9,
         gpu_shader_int16                          = 1 << 10,
         gpu_shader_half_float                     = 1 << 11,
+        nv_gpu_shader5_types                      = 1 << 12,
     } feature;
     void insert(feature f) { features |= f; }
     void erase(feature f) { features &= ~f; }
@@ -342,6 +343,7 @@ public:
         numTaskNVBlocks(0),
         layoutPrimitiveCulling(false),
         numTaskEXTPayloads(0),
+        nonCoherentTileAttachmentReadQCOM(false),
         autoMapBindings(false),
         autoMapLocations(false),
         flattenUniformArrays(false),
@@ -370,6 +372,12 @@ public:
         localSizeSpecId[1] = TQualifier::layoutNotSet;
         localSizeSpecId[2] = TQualifier::layoutNotSet;
         xfbBuffers.resize(TQualifier::layoutXfbBufferEnd);
+        tileShadingRateQCOM[0] = 0;
+        tileShadingRateQCOM[1] = 0;
+        tileShadingRateQCOM[2] = 0;
+        tileShadingRateQCOMNotDefault[0] = false;
+        tileShadingRateQCOMNotDefault[1] = false;
+        tileShadingRateQCOMNotDefault[2] = false;
         shiftBinding.fill(0);
     }
 
@@ -439,6 +447,9 @@ public:
         case EShTargetVulkan_1_3:
             processes.addProcess("target-env vulkan1.3");
             break;
+        case EShTargetVulkan_1_4:
+            processes.addProcess("target-env vulkan1.4");
+            break;
         default:
             processes.addProcess("target-env vulkanUnknown");
             break;
@@ -647,6 +658,21 @@ public:
 
     bool isEsProfile() const { return profile == EEsProfile; }
 
+    bool setTileShadingRateQCOM(int dim, int size)
+    {
+        if (tileShadingRateQCOMNotDefault[dim])
+            return size == tileShadingRateQCOM[dim];
+        tileShadingRateQCOMNotDefault[dim] = true;
+        tileShadingRateQCOM[dim] = size;
+        return true;
+    }
+    unsigned int getTileShadingRateQCOM(int dim) const { return tileShadingRateQCOM[dim]; }
+    bool isTileShadingRateQCOMSet() const
+    {
+        // Return true if any component has been set (i.e. any component is not default).
+        return tileShadingRateQCOMNotDefault[0] || tileShadingRateQCOMNotDefault[1] || tileShadingRateQCOMNotDefault[2];
+    }
+
     void setShiftBinding(TResourceType res, unsigned int shift)
     {
         shiftBinding[res] = shift;
@@ -892,6 +918,8 @@ public:
     bool getNonCoherentDepthAttachmentReadEXT() const { return nonCoherentDepthAttachmentReadEXT; }
     void setNonCoherentStencilAttachmentReadEXT() { nonCoherentStencilAttachmentReadEXT = true; }
     bool getNonCoherentStencilAttachmentReadEXT() const { return nonCoherentStencilAttachmentReadEXT; }
+    void setNonCoherentTileAttachmentReadQCOM() { nonCoherentTileAttachmentReadQCOM = true; }
+    bool getNonCoherentTileAttachmentReadQCOM() const { return nonCoherentTileAttachmentReadQCOM; }
     void setPostDepthCoverage() { postDepthCoverage = true; }
     bool getPostDepthCoverage() const { return postDepthCoverage; }
     void setEarlyFragmentTests() { earlyFragmentTests = true; }
@@ -1032,11 +1060,11 @@ public:
 #endif
 
     bool usingScalarBlockLayout() const {
-        for (auto extIt = requestedExtensions.begin(); extIt != requestedExtensions.end(); ++extIt) {
-            if (*extIt == E_GL_EXT_scalar_block_layout)
-                return true;
-        }
-        return false;
+        return IsRequestedExtension(E_GL_EXT_scalar_block_layout);
+    }
+
+    bool usingTextureOffsetNonConst() const {
+        return IsRequestedExtension(E_GL_EXT_texture_offset_non_const);
     }
 
     bool IsRequestedExtension(const char* extension) const
@@ -1050,7 +1078,9 @@ public:
 
     void mergeGlobalUniformBlocks(TInfoSink& infoSink, TIntermediate& unit, bool mergeExistingOnly);
     void mergeUniformObjects(TInfoSink& infoSink, TIntermediate& unit);
-    void checkStageIO(EShMessages, TInfoSink&, TIntermediate&);
+    void mergeImplicitArraySizes(TInfoSink& infoSink, TIntermediate& unit);
+    void checkStageIO(TInfoSink&, TIntermediate&, EShMessages);
+    void optimizeStageIO(TInfoSink&, TIntermediate&);
 
     bool buildConvertOp(TBasicType dst, TBasicType src, TOperator& convertOp) const;
     TIntermTyped* createConversion(TBasicType convertTo, TIntermTyped* node) const;
@@ -1063,6 +1093,7 @@ public:
     int checkLocationRT(int set, int location);
     int addUsedOffsets(int binding, int offset, int numOffsets);
     bool addUsedConstantId(int id);
+    GLSLANG_EXPORT_FOR_TESTS
     static int computeTypeLocationSize(const TType&, EShLanguage);
     static int computeTypeUniformLocationSize(const TType&);
 
@@ -1101,26 +1132,35 @@ public:
     // Certain explicit conversions are allowed conditionally
     bool getArithemeticInt8Enabled() const {
         return numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
+               numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_int8);
     }
     bool getArithemeticInt16Enabled() const {
         return numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
                numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+               numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_int16);
     }
 
     bool getArithemeticFloat16Enabled() const {
         return numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
                numericFeatures.contains(TNumericFeatures::gpu_shader_half_float) ||
+               numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_float16);
     }
     void updateNumericFeature(TNumericFeatures::feature f, bool on)
         { on ? numericFeatures.insert(f) : numericFeatures.erase(f); }
 
 protected:
-    TIntermSymbol* addSymbol(long long Id, const TString&, const TType&, const TConstUnionArray&, TIntermTyped* subtree, const TSourceLoc&);
-    void error(TInfoSink& infoSink, const char*, EShLanguage unitStage = EShLangCount);
-    void warn(TInfoSink& infoSink, const char*, EShLanguage unitStage = EShLangCount);
+    TIntermSymbol* addSymbol(long long Id, const TString&, const TString&, const TType&, const TConstUnionArray&, TIntermTyped* subtree, const TSourceLoc&);
+    void error(TInfoSink& infoSink, const TSourceLoc* loc, EShMessages messages, const char*, EShLanguage unitStage = EShLangCount);
+    void error(TInfoSink& infoSink, const char* message, EShLanguage unitStage = EShLangCount) {
+        error(infoSink, nullptr, EShMsgDefault, message, unitStage);
+    }
+    void warn(TInfoSink& infoSink, const TSourceLoc* loc, EShMessages, const char*, EShLanguage unitStage = EShLangCount);
+    void warn(TInfoSink& infoSink, const char* message, EShLanguage unitStage = EShLangCount) {
+        warn(infoSink, nullptr, EShMsgDefault, message, unitStage);
+    }
     void mergeCallGraphs(TInfoSink&, TIntermediate&);
     void mergeModes(TInfoSink&, TIntermediate&);
     void mergeTrees(TInfoSink&, TIntermediate&);
@@ -1130,7 +1170,7 @@ protected:
     void mergeLinkerObjects(TInfoSink&, TIntermSequence& linkerObjects, const TIntermSequence& unitLinkerObjects, EShLanguage);
     void mergeBlockDefinitions(TInfoSink&, TIntermSymbol* block, TIntermSymbol* unitBlock, TIntermediate* unitRoot);
     void mergeImplicitArraySizes(TType&, const TType&);
-    void mergeErrorCheck(TInfoSink&, const TIntermSymbol&, const TIntermSymbol&, EShLanguage);
+    void mergeErrorCheck(TInfoSink&, const TIntermSymbol&, const TIntermSymbol&);
     void checkCallGraphCycles(TInfoSink&);
     void checkCallGraphBodies(TInfoSink&, bool keepUncalled);
     void inOutLocationCheck(TInfoSink&);
@@ -1226,6 +1266,10 @@ protected:
     bool layoutPrimitiveCulling;
     int numTaskEXTPayloads;
 
+    bool nonCoherentTileAttachmentReadQCOM;
+    int  tileShadingRateQCOM[3];
+    bool tileShadingRateQCOMNotDefault[3];
+
     // Base shift values
     std::array<unsigned int, EResCount> shiftBinding;
 

+ 6 - 0
src/libraries/glslang/glslang/MachineIndependent/parseVersions.h

@@ -103,6 +103,9 @@ public:
     virtual void doubleCheck(const TSourceLoc&, const char* op);
     virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void float16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void bfloat16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void floate5m2ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void floate4m3ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual bool float16Arithmetic();
     virtual void requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc);
     virtual void int16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
@@ -121,6 +124,9 @@ public:
     virtual void fcoopmatCheckNV(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void intcoopmatCheckNV(const TSourceLoc&, const char *op, bool builtIn = false);
     virtual void coopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void tensorLayoutViewCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void coopvecCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void intattachmentCheck(const TSourceLoc&, const char *op, bool builtIn = false);
     bool relaxedErrors()    const { return (messages & EShMsgRelaxedErrors) != 0; }
     bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; }
     bool isForwardCompatible() const { return forwardCompatible; }

+ 4 - 2
src/libraries/glslang/glslang/MachineIndependent/preprocessor/Pp.cpp

@@ -241,6 +241,7 @@ int TPpContext::CPPundef(TPpToken* ppToken)
 */
 int TPpContext::CPPelse(int matchelse, TPpToken* ppToken)
 {
+    inElseSkip = true;
     int depth = 0;
     int token = scanToken(ppToken);
 
@@ -297,7 +298,7 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken)
                     elseSeen[elsetracker] = false;
                     --elsetracker;
                 }
-
+                inElseSkip = false;
                 return CPPif(ppToken);
             }
         } else if (nextAtom == PpAtomElse) {
@@ -311,7 +312,8 @@ int TPpContext::CPPelse(int matchelse, TPpToken* ppToken)
                 parseContext.ppError(ppToken->loc, "#elif after #else", "#elif", "");
         }
     }
-
+    
+    inElseSkip = false;
     return token;
 }
 

+ 2 - 1
src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpContext.cpp

@@ -88,7 +88,8 @@ TPpContext::TPpContext(TParseContextBase& pc, const std::string& rootFileName, T
     preamble(nullptr), strings(nullptr), previous_token('\n'), parseContext(pc), includer(inclr), inComment(false),
     rootFileName(rootFileName),
     currentSourceFile(rootFileName),
-    disableEscapeSequences(false)
+    disableEscapeSequences(false),
+    inElseSkip(false)
 {
     ifdepth = 0;
     for (elsetracker = 0; elsetracker < maxIfNesting; elsetracker++)

+ 4 - 1
src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpContext.h

@@ -371,7 +371,7 @@ protected:
                 break;
             popInput();
         }
-        if (!inputStack.empty() && inputStack.back()->isStringInput()) {
+        if (!inputStack.empty() && inputStack.back()->isStringInput() && !inElseSkip) {
             if (token == '\n') {
                 bool seenNumSign = false;
                 for (int i = 0; i < (int)lastLineTokens.size() - 1;) {
@@ -732,6 +732,9 @@ protected:
 
     std::istringstream strtodStream;
     bool disableEscapeSequences;
+    // True if we're skipping a section enclosed by #if/#ifdef/#elif/#else which was evaluated to
+    // be inactive, e.g. #if 0
+    bool inElseSkip;
 };
 
 } // end namespace glslang

+ 1 - 0
src/libraries/glslang/glslang/MachineIndependent/preprocessor/PpScanner.cpp

@@ -470,6 +470,7 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
     static const char* const Int64_Extensions[] = {
         E_GL_ARB_gpu_shader_int64,
         E_GL_EXT_shader_explicit_arithmetic_types,
+        E_GL_NV_gpu_shader5,
         E_GL_EXT_shader_explicit_arithmetic_types_int64 };
     static const int Num_Int64_Extensions = sizeof(Int64_Extensions) / sizeof(Int64_Extensions[0]);
 

+ 3 - 0
src/libraries/glslang/glslang/MachineIndependent/propagateNoContraction.cpp

@@ -174,6 +174,9 @@ bool isArithmeticOperation(glslang::TOperator op)
     case glslang::EOpMatrixTimesMatrix:
 
     case glslang::EOpDot:
+    case glslang::EOpDotPackedEXT:
+    case glslang::EOpDotAccSatEXT:
+    case glslang::EOpDotPackedAccSatEXT:
 
     case glslang::EOpPostIncrement:
     case glslang::EOpPostDecrement:

+ 2 - 1
src/libraries/glslang/glslang/MachineIndependent/propagateNoContraction.h

@@ -52,4 +52,5 @@ namespace glslang {
 // 'noContraction' means the object is 'precise'; and for arithmetic operation
 // nodes, it means the operation should not be contracted.
 void PropagateNoContraction(const glslang::TIntermediate& intermediate);
-};
+
+} // end namespace glslang

+ 10 - 3
src/libraries/glslang/glslang/MachineIndependent/reflection.cpp

@@ -1148,8 +1148,10 @@ void TReflection::buildAttributeReflection(EShLanguage stage, const TIntermediat
 {
     if (stage == EShLangCompute) {
         // Remember thread dimensions
-        for (int dim=0; dim<3; ++dim)
+        for (int dim=0; dim<3; ++dim) {
             localSize[dim] = intermediate.getLocalSize(dim);
+            tileShadingRateQCOM[dim] = intermediate.getTileShadingRateQCOM(dim);
+        }
     }
 }
 
@@ -1280,9 +1282,8 @@ void TReflection::dump()
         indexToPipeOutput[i].dump();
     printf("\n");
 
+    static const char* axis[] = { "X", "Y", "Z" };
     if (getLocalSize(0) > 1) {
-        static const char* axis[] = { "X", "Y", "Z" };
-
         for (int dim=0; dim<3; ++dim)
             if (getLocalSize(dim) > 1)
                 printf("Local size %s: %u\n", axis[dim], getLocalSize(dim));
@@ -1290,6 +1291,12 @@ void TReflection::dump()
         printf("\n");
     }
 
+    if (getTileShadingRateQCOM(0) > 1 || getTileShadingRateQCOM(1) > 1) {
+        for (int dim=0; dim<3; ++dim)
+            printf("Tile shading rate QCOM %s: %u\n", axis[dim], getTileShadingRateQCOM(dim));
+        printf("\n");
+    }
+
     // printf("Live names\n");
     // for (TNameToIndex::const_iterator it = nameToIndex.begin(); it != nameToIndex.end(); ++it)
     //    printf("%s: %d\n", it->first.c_str(), it->second);

+ 10 - 3
src/libraries/glslang/glslang/MachineIndependent/reflection.h

@@ -37,8 +37,8 @@
 #define _REFLECTION_INCLUDED
 
 #include "../Public/ShaderLang.h"
-#include "../Include/Types.h"
-
+#include "../Include/BaseTypes.h"
+#include "../Include/visibility.h"
 #include <list>
 #include <set>
 
@@ -58,13 +58,16 @@ public:
     TReflection(EShReflectionOptions opts, EShLanguage first, EShLanguage last)
         : options(opts), firstStage(first), lastStage(last), badReflection(TObjectReflection::badReflection())
     { 
-        for (int dim=0; dim<3; ++dim)
+        for (int dim=0; dim<3; ++dim) {
             localSize[dim] = 0;
+            tileShadingRateQCOM[dim] = 0;
+        }
     }
 
     virtual ~TReflection() {}
 
     // grow the reflection stage by stage
+    GLSLANG_EXPORT_FOR_TESTS
     bool addStage(EShLanguage, const TIntermediate&);
 
     // for mapping a uniform index to a uniform object's description
@@ -167,6 +170,9 @@ public:
     // Thread local size
     unsigned getLocalSize(int dim) const { return dim <= 2 ? localSize[dim] : 0; }
 
+    // Tile shading rate QCOM
+    unsigned getTileShadingRateQCOM(int dim) const { return dim <= 2 ? tileShadingRateQCOM[dim] : 0; }
+
     void dump();
 
 protected:
@@ -212,6 +218,7 @@ protected:
     TIndices atomicCounterUniformIndices;
 
     unsigned int localSize[3];
+    unsigned int tileShadingRateQCOM[3];
 };
 
 } // end namespace glslang

+ 2 - 1
src/libraries/glslang/glslang/OSDependent/osinclude.h

@@ -35,9 +35,10 @@
 #ifndef __OSINCLUDE_H
 #define __OSINCLUDE_H
 
+#include "../Include/visibility.h"
 namespace glslang {
 
-void OS_DumpMemoryCounters();
+GLSLANG_EXPORT void OS_DumpMemoryCounters();
 
 } // end namespace glslang
 

+ 5 - 4
src/libraries/glslang/glslang/Public/ResourceLimits.h

@@ -38,20 +38,21 @@
 #include <string>
 
 #include "../Include/ResourceLimits.h"
+#include "../Include/visibility.h"
 
 // Return pointer to user-writable Resource to pass through API in
 // future-proof way.
-extern TBuiltInResource* GetResources();
+GLSLANG_EXPORT extern TBuiltInResource* GetResources();
 
 // These are the default resources for TBuiltInResources, used for both
 //  - parsing this string for the case where the user didn't supply one,
 //  - dumping out a template for user construction of a config file.
-extern const TBuiltInResource* GetDefaultResources();
+GLSLANG_EXPORT extern const TBuiltInResource* GetDefaultResources();
 
 // Returns the DefaultTBuiltInResource as a human-readable string.
-std::string GetDefaultTBuiltInResourceString();
+GLSLANG_EXPORT std::string GetDefaultTBuiltInResourceString();
 
 // Decodes the resource limits from |config| to |resources|.
-void DecodeResourceLimits(TBuiltInResource* resources, char* config);
+GLSLANG_EXPORT void DecodeResourceLimits(TBuiltInResource* resources, char* config);
 
 #endif  // _STAND_ALONE_RESOURCE_LIMITS_INCLUDED_

+ 43 - 18
src/libraries/glslang/glslang/Public/ShaderLang.h

@@ -38,6 +38,7 @@
 #define _COMPILER_INTERFACE_INCLUDED_
 
 #include "../Include/ResourceLimits.h"
+#include "../Include/visibility.h"
 #include "../MachineIndependent/Versions.h"
 
 #include <cstring>
@@ -49,22 +50,6 @@
     #define C_DECL
 #endif
 
-#ifdef GLSLANG_IS_SHARED_LIBRARY
-    #ifdef _WIN32
-        #ifdef GLSLANG_EXPORTING
-            #define GLSLANG_EXPORT __declspec(dllexport)
-        #else
-            #define GLSLANG_EXPORT __declspec(dllimport)
-        #endif
-    #elif __GNUC__ >= 4
-        #define GLSLANG_EXPORT __attribute__((visibility("default")))
-    #endif
-#endif // GLSLANG_IS_SHARED_LIBRARY
-
-#ifndef GLSLANG_EXPORT
-#define GLSLANG_EXPORT
-#endif
-
 //
 // This is the platform independent interface between an OGL driver
 // and the shading language compiler/linker.
@@ -172,8 +157,9 @@ typedef enum {
     EShTargetVulkan_1_1 = (1 << 22) | (1 << 12),      // Vulkan 1.1
     EShTargetVulkan_1_2 = (1 << 22) | (2 << 12),      // Vulkan 1.2
     EShTargetVulkan_1_3 = (1 << 22) | (3 << 12),      // Vulkan 1.3
+    EShTargetVulkan_1_4 = (1 << 22) | (4 << 12),      // Vulkan 1.4
     EShTargetOpenGL_450 = 450,                        // OpenGL
-    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 5),
+    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 6),
 } EShTargetClientVersion;
 
 typedef EShTargetClientVersion EshTargetClientVersion;
@@ -189,6 +175,21 @@ typedef enum {
     LAST_ELEMENT_MARKER(EShTargetLanguageVersionCount = 7),
 } EShTargetLanguageVersion;
 
+//
+// Following are a series of helper enums for managing layouts and qualifiers,
+// used for TPublicType, TType, others.
+//
+
+enum TLayoutPacking {
+    ElpNone,
+    ElpShared, // default, but different than saying nothing
+    ElpStd140,
+    ElpStd430,
+    ElpPacked,
+    ElpScalar,
+    ElpCount // If expanding, see bitfield width below
+};
+
 struct TInputLanguage {
     EShSource languageFamily; // redundant information with other input, this one overrides when not EShSourceNone
     EShLanguage stage;        // redundant information with other input, this one overrides when not EShSourceNone
@@ -272,7 +273,8 @@ enum EShMessages : unsigned {
     EShMsgEnhanced             = (1 << 15), // enhanced message readability
     EShMsgAbsolutePath         = (1 << 16), // Output Absolute path for messages
     EShMsgDisplayErrorColumn   = (1 << 17), // Display error message column aswell as line
-    EshMsgCrossStageIO         = (1 << 28), // Always validate cross-stage IO
+    EShMsgLinkTimeOptimization = (1 << 18), // perform cross-stage optimizations during linking
+    EShMsgValidateCrossStageIO = (1 << 19), // validate shader inputs have matching outputs in previous stage
     EshMsgOverlappingLocations = (1 << 29), // Always validate overlapping layout locations
     LAST_ELEMENT_MARKER(EShMsgCount),
 };
@@ -418,6 +420,7 @@ GLSLANG_EXPORT int GetKhronosToolId();
 class TIntermediate;
 class TProgram;
 class TPoolAllocator;
+class TIoMapResolver;
 
 // Call this exactly once per process before using anything else
 GLSLANG_EXPORT bool InitializeProcess();
@@ -513,6 +516,9 @@ public:
     GLSLANG_EXPORT void setAtomicCounterBlockSet(unsigned int set);
     GLSLANG_EXPORT void setAtomicCounterBlockBinding(unsigned int binding);
 
+    GLSLANG_EXPORT void addSourceText(const char* text, size_t len);
+    GLSLANG_EXPORT void setSourceFile(const char* file);
+
     // For setting up the environment (cleared to nothingness in the constructor).
     // These must be called so that parsing is done for the right source language and
     // target environment, either indirectly through TranslateEnvironment() based on
@@ -855,6 +861,20 @@ public:
     virtual void addStage(EShLanguage stage, TIntermediate& stageIntermediate) = 0;
 };
 
+// I/O mapper
+class TIoMapper {
+public:
+    TIoMapper() {}
+    virtual ~TIoMapper() {}
+    // grow the reflection stage by stage
+    bool virtual addStage(EShLanguage, TIntermediate&, TInfoSink&, TIoMapResolver*);
+    bool virtual doMap(TIoMapResolver*, TInfoSink&) { return true; }
+    bool virtual setAutoPushConstantBlock(const char*, unsigned int, TLayoutPacking) { return false; }
+};
+
+// Get the default GLSL IO mapper
+GLSLANG_EXPORT TIoMapper* GetGlslIoMapper();
+
 // Make one TProgram per set of shaders that will get linked together.  Add all
 // the shaders that are to be linked together.  After calling shader.parse()
 // for all shaders, call link().
@@ -879,6 +899,7 @@ public:
     // call first, to do liveness analysis, index mapping, etc.; returns false on failure
     GLSLANG_EXPORT bool buildReflection(int opts = EShReflectionDefault);
     GLSLANG_EXPORT unsigned getLocalSize(int dim) const;                  // return dim'th local size
+    GLSLANG_EXPORT unsigned getTileShadingRateQCOM(int dim) const;        // return dim'th tile shading rate QCOM
     GLSLANG_EXPORT int getReflectionIndex(const char *name) const;
     GLSLANG_EXPORT int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const;
     GLSLANG_EXPORT int getNumUniformVariables() const;
@@ -962,6 +983,10 @@ public:
     const TType *getAttributeTType(int index) const    { return getPipeInput(index).getType(); }
 
     GLSLANG_EXPORT void dumpReflection();
+
+    // Get the IO resolver to use for mapIO
+    GLSLANG_EXPORT TIoMapResolver* getGlslIoResolver(EShLanguage stage);
+
     // I/O mapping: apply base offsets and map live unbound variables
     // If resolver is not provided it uses the previous approach
     // and respects auto assignment and offsets.

+ 2 - 2
src/libraries/glslang/glslang/build_info.h

@@ -34,8 +34,8 @@
 #ifndef GLSLANG_BUILD_INFO
 #define GLSLANG_BUILD_INFO
 
-#define GLSLANG_VERSION_MAJOR 14
-#define GLSLANG_VERSION_MINOR 0
+#define GLSLANG_VERSION_MAJOR 15
+#define GLSLANG_VERSION_MINOR 3
 #define GLSLANG_VERSION_PATCH 0
 #define GLSLANG_VERSION_FLAVOR ""
 

+ 1 - 1
src/modules/graphics/Shader.cpp

@@ -1253,7 +1253,7 @@ bool Shader::validateInternal(StrongRef<ShaderStage> stages[], std::string &err,
 			program.addShader(stages[i]->getGLSLangValidationShader());
 	}
 
-	if (!program.link((EShMessages)(EshMsgCrossStageIO | EshMsgOverlappingLocations)))
+	if (!program.link((EShMessages)(EShMsgValidateCrossStageIO | EshMsgOverlappingLocations)))
 	{
 		err = "Cannot compile shader:\n\n" + std::string(program.getInfoLog()) + "\n" + std::string(program.getInfoDebugLog());
 		return false;

部分文件因为文件数量过多而无法显示