Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package spirv-headers for openSUSE:Factory checked in at 2023-08-30 10:17:42 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/spirv-headers (Old) and /work/SRC/openSUSE:Factory/.spirv-headers.new.1766 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "spirv-headers" Wed Aug 30 10:17:42 2023 rev:37 rq:1105510 version:1.6.1+sdk261 Changes: -------- --- /work/SRC/openSUSE:Factory/spirv-headers/spirv-headers.changes 2023-06-03 00:05:19.369315490 +0200 +++ /work/SRC/openSUSE:Factory/.spirv-headers.new.1766/spirv-headers.changes 2023-08-30 10:18:34.900075988 +0200 @@ -1,0 +2,13 @@ +Tue Aug 22 09:47:59 UTC 2023 - Jan Engelhardt <[email protected]> + +- Update to release SDK-1.3.261.0 + * Header files changes to support SPV_INTEL_fp_max_error spec + extension + * Make the generated operators for masks constexpr + * Add definitions for SVP_EXT_image_raw10_raw12, + SPV_KHR_cooperative_matrix + * Remove capabilities on cooperative matrix enums to align with + specification + * Revert "Add support for fp_max_error extension" + +------------------------------------------------------------------- Old: ---- sdk-1.3.250.tar.gz New: ---- sdk-1.3.261.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ spirv-headers.spec ++++++ --- /var/tmp/diff_new_pack.1xLdzq/_old 2023-08-30 10:18:35.920112390 +0200 +++ /var/tmp/diff_new_pack.1xLdzq/_new 2023-08-30 10:18:35.924112532 +0200 @@ -24,8 +24,8 @@ # and the independently increasing toolchain release number (239). Name: spirv-headers -Version: 1.6.1+sdk250 -%define innerver 1.3.250 +Version: 1.6.1+sdk261 +%define innerver 1.3.261 Release: 0 Summary: Machine-readable files from the SPIR-V registry License: MIT ++++++ sdk-1.3.250.tar.gz -> sdk-1.3.261.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/SECURITY.md new/SPIRV-Headers-sdk-1.3.261/SECURITY.md --- old/SPIRV-Headers-sdk-1.3.250/SECURITY.md 1970-01-01 01:00:00.000000000 +0100 +++ new/SPIRV-Headers-sdk-1.3.261/SECURITY.md 2023-08-04 19:44:58.000000000 +0200 @@ -0,0 +1,13 @@ +# Security Policy + +## Supported Versions + +Security updates are applied only to the latest release. + +## Reporting a Vulnerability + +If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released. + +Please disclose it at [security advisory](https://github.com/KhronosGroup/SPIRV-Headers/security/advisories/new). + +This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/spir-v.xml new/SPIRV-Headers-sdk-1.3.261/include/spirv/spir-v.xml --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/spir-v.xml 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/spir-v.xml 2023-08-04 19:44:58.000000000 +0200 @@ -82,12 +82,15 @@ <id value="29" vendor="Mikkosoft Productions" tool="MSP Shader Compiler" comment="Contact Mikko Rasa, [email protected]"/> <id value="30" vendor="SpvGenTwo community" tool="SpvGenTwo SPIR-V IR Tools" comment="https://github.com/rAzoR8/SpvGenTwo"/> <id value="31" vendor="Google" tool="Skia SkSL" comment="Contact Ethan Nicholas, [email protected]"/> - <id value="32" vendor="TornadoVM" tool="SPIRV Beehive Toolkit" comment="https://github.com/beehive-lab/spirv-beehive-toolkit"/> + <id value="32" vendor="TornadoVM" tool="Beehive SPIRV Toolkit" comment="https://github.com/beehive-lab/beehive-spirv-toolkit"/> <id value="33" vendor="DragonJoker" tool="ShaderWriter" comment="Contact Sylvain Doremus, https://github.com/DragonJoker/ShaderWriter"/> <id value="34" vendor="Rayan Hatout" tool="SPIRVSmith" comment="Contact Rayan Hatout [email protected], Repo https://github.com/rayanht/SPIRVSmith"/> <id value="35" vendor="Saarland University" tool="Shady" comment="Contact Hugo Devillers [email protected], Repo https://github.com/Hugobros3/shady"/> <id value="36" vendor="Taichi Graphics" tool="Taichi" comment="Contact Rendong Liang [email protected], Repo https://github.com/taichi-dev/taichi"/> - <unused start="37" end="0xFFFF" comment="Tool ID range reservable for future use by vendors"/> + <id value="37" vendor="heroseh" tool="Hero C Compiler" comment="https://github.com/heroseh/hcc"/> + <id value="38" vendor="Meta" tool="SparkSL" comment="Contact Dunfan Lu, [email protected], https://sparkar.facebook.com/ar-studio/learn/sparksl/sparksl-overview"/> + <id value="39" vendor="SirLynix" tool="Nazara ShaderLang Compiler" comment="Contact Jérôme Leclercq, https://github.com/NazaraEngine/ShaderLang"/> + <unused start="40" end="0xFFFF" comment="Tool ID range reservable for future use by vendors"/> </ids> <!-- SECTION: SPIR-V Opcodes and Enumerants --> @@ -143,6 +146,7 @@ <ids type="opcode" start="6464" end="6527" vendor="N/A" comment="Blank range to keep alignment with non-opcodes"/> <ids type="opcode" start="6528" end="6591" vendor="Codeplay" comment="Contact [email protected]"/> <ids type="opcode" start="6592" end="6655" vendor="Saarland University" comment="Contact [email protected]"/> + <ids type="opcode" start="6656" end="6719" vendor="Meta" comment="Contact [email protected]"/> <!-- Opcode enumerants to reserve for future use. To get a block, allocate multiples of 64 starting at the lowest available point in this block and add a corresponding <ids> tag immediately above. Make @@ -175,6 +179,7 @@ <ids type="enumerant" start="6464" end="6527" vendor="Mikkosoft Productions" comment="Contact Mikko Rasa, [email protected]"/> <ids type="enumerant" start="6528" end="6591" vendor="Codeplay" comment="Contact [email protected]"/> <ids type="enumerant" start="6592" end="6655" vendor="Saarland University" comment="Contact [email protected]"/> + <ids type="enumerant" start="6656" end="6719" vendor="Meta" comment="Contact [email protected]"/> <!-- Enumerants to reserve for future use. To get a block, allocate multiples of 64 starting at the lowest available point in this block and add a corresponding <ids> tag immediately above. Make diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.bf new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.bf --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.bf 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.bf 2023-08-04 19:44:58.000000000 +0200 @@ -66,6 +66,9 @@ HLSL = 5, CPP_for_OpenCL = 6, SYCL = 7, + HERO_C = 8, + NZSL = 9, + WGSL = 10, } [AllowDuplicates, CRepr] public enum ExecutionModel @@ -353,6 +356,8 @@ Float = 14, UnormInt24 = 15, UnormInt101010_2 = 16, + UnsignedIntRaw10EXT = 19, + UnsignedIntRaw12EXT = 20, } [AllowDuplicates, CRepr] public enum ImageOperandsShift @@ -583,6 +588,7 @@ SingleElementVectorINTEL = 6085, VectorComputeCallableFunctionINTEL = 6087, MediaBlockIOINTEL = 6140, + FPMaxErrorDecorationINTEL = 6170, LatencyControlLabelINTEL = 6172, LatencyControlConstraintINTEL = 6173, ConduitKernelArgumentINTEL = 6175, @@ -1157,6 +1163,7 @@ DotProduct = 6019, DotProductKHR = 6019, RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, BitInstructions = 6025, GroupNonUniformRotateKHR = 6026, AtomicFloat32AddEXT = 6033, @@ -1168,6 +1175,7 @@ BFloat16ConversionINTEL = 6115, SplitBarrierINTEL = 6141, FPGAKernelAttributesv2INTEL = 6161, + FPMaxErrorINTEL = 6169, FPGALatencyControlINTEL = 6171, FPGAArgumentInterfacesINTEL = 6174, GroupUniformArithmeticKHR = 6400, @@ -1278,6 +1286,38 @@ PackedVectorFormat4x8BitKHR = 0, } + [AllowDuplicates, CRepr] public enum CooperativeMatrixOperandsShift + { + MatrixASignedComponentsKHR = 0, + MatrixBSignedComponentsKHR = 1, + MatrixCSignedComponentsKHR = 2, + MatrixResultSignedComponentsKHR = 3, + SaturatingAccumulationKHR = 4, + } + + [AllowDuplicates, CRepr] public enum CooperativeMatrixOperandsMask + { + MaskNone = 0, + MatrixASignedComponentsKHR = 0x00000001, + MatrixBSignedComponentsKHR = 0x00000002, + MatrixCSignedComponentsKHR = 0x00000004, + MatrixResultSignedComponentsKHR = 0x00000008, + SaturatingAccumulationKHR = 0x00000010, + } + + [AllowDuplicates, CRepr] public enum CooperativeMatrixLayout + { + RowMajorKHR = 0, + ColumnMajorKHR = 1, + } + + [AllowDuplicates, CRepr] public enum CooperativeMatrixUse + { + MatrixAKHR = 0, + MatrixBKHR = 1, + MatrixAccumulatorKHR = 2, + } + [AllowDuplicates, CRepr] public enum Op { OpNop = 0, @@ -1652,6 +1692,11 @@ OpUDotAccSatKHR = 4454, OpSUDotAccSat = 4455, OpSUDotAccSatKHR = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.core.grammar.json new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.core.grammar.json --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.core.grammar.json 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.core.grammar.json 2023-08-04 19:44:58.000000000 +0200 @@ -4494,6 +4494,77 @@ "version" : "1.6" }, { + "opname" : "OpTypeCooperativeMatrixKHR", + "class" : "Type-Declaration", + "opcode" : 4456, + "operands" : [ + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Component Type'" }, + { "kind" : "IdScope", "name" : "'Scope'" }, + { "kind" : "IdRef", "name" : "'Rows'" }, + { "kind" : "IdRef", "name" : "'Columns'" }, + { "kind" : "IdRef", "name" : "'Use'" } + ], + "capabilities" : [ "CooperativeMatrixKHR" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixLoadKHR", + "class" : "Memory", + "opcode" : 4457, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'MemoryLayout'" }, + { "kind" : "IdRef", "name" : "'Stride'", "quantifier": "?" }, + { "kind" : "MemoryAccess", "name" : "'Memory Operand'", "quantifier" : "?" } + ], + "capabilities" : [ "CooperativeMatrixKHR" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixStoreKHR", + "class" : "Memory", + "opcode" : 4458, + "operands" : [ + { "kind" : "IdRef", "name" : "'Pointer'" }, + { "kind" : "IdRef", "name" : "'Object'" }, + { "kind" : "IdRef", "name" : "'MemoryLayout'" }, + { "kind" : "IdRef", "name" : "'Stride'", "quantifier": "?" }, + { "kind" : "MemoryAccess", "name" : "'Memory Operand'", "quantifier" : "?" } + ], + "capabilities" : [ "CooperativeMatrixKHR" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixMulAddKHR", + "class" : "Arithmetic", + "opcode" : 4459, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'A'" }, + { "kind" : "IdRef", "name" : "'B'" }, + { "kind" : "IdRef", "name" : "'C'" }, + { "kind" : "CooperativeMatrixOperands", "name" : "'Cooperative Matrix Operands'", "quantifier" : "?" } + ], + "capabilities" : [ "CooperativeMatrixKHR" ], + "version" : "None" + }, + { + "opname" : "OpCooperativeMatrixLengthKHR", + "class" : "Miscellaneous", + "opcode" : 4460, + "operands" : [ + { "kind" : "IdResultType" }, + { "kind" : "IdResult" }, + { "kind" : "IdRef", "name" : "'Type'" } + ], + "capabilities" : [ "CooperativeMatrixKHR" ], + "version" : "None" + }, + { "opname" : "OpTypeRayQueryKHR", "class" : "Reserved", "opcode" : 4472, @@ -10084,6 +10155,18 @@ { "enumerant" : "SYCL", "value" : 7 + }, + { + "enumerant" : "HERO_C", + "value" : 8 + }, + { + "enumerant" : "NZSL", + "value" : 9 + }, + { + "enumerant" : "WGSL", + "value" : 10 } ] }, @@ -11606,6 +11689,16 @@ "enumerant" : "UnormInt101010_2", "value" : 16, "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnsignedIntRaw10EXT", + "value" : 19, + "capabilities" : [ "Kernel" ] + }, + { + "enumerant" : "UnsignedIntRaw12EXT", + "value" : 20, + "capabilities" : [ "Kernel" ] } ] }, @@ -12708,6 +12801,15 @@ "version" : "None" }, { + "enumerant" : "FPMaxErrorDecorationINTEL", + "value" : 6170, + "parameters" : [ + { "kind" : "LiteralFloat", "name" : "'Max Error'" } + ], + "capabilities" : [ "FPMaxErrorINTEL" ], + "version" : "None" + }, + { "enumerant" : "LatencyControlLabelINTEL", "value" : 6172, "parameters" : [ @@ -15105,6 +15207,12 @@ "version" : "None" }, { + "enumerant" : "CooperativeMatrixKHR", + "value" : 6022, + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { "enumerant" : "BitInstructions", "value" : 6025, "extensions" : [ "SPV_KHR_bit_instructions" ], @@ -15173,6 +15281,12 @@ "version" : "None" }, { + "enumerant" : "FPMaxErrorINTEL", + "value" : 6169, + "extensions" : [ "SPV_INTEL_fp_max_error" ], + "version" : "None" + }, + { "enumerant" : "FPGALatencyControlINTEL", "value" : 6171, "extensions" : [ "SPV_INTEL_fpga_latency_control" ], @@ -15269,6 +15383,90 @@ } ] }, + { + "category" : "BitEnum", + "kind" : "CooperativeMatrixOperands", + "enumerants" : [ + { + "enumerant" : "NoneKHR", + "value" : "0x0000", + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "MatrixASignedComponentsKHR", + "value" : "0x0001", + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "MatrixBSignedComponentsKHR", + "value" : "0x0002", + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "MatrixCSignedComponentsKHR", + "value" : "0x0004", + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "MatrixResultSignedComponentsKHR", + "value" : "0x0008", + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "SaturatingAccumulationKHR", + "value" : "0x0010", + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "CooperativeMatrixLayout", + "enumerants" : [ + { + "enumerant" : "RowMajorKHR", + "value" : 0, + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "ColumnMajorKHR", + "value" : 1, + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + } + ] + }, + { + "category" : "ValueEnum", + "kind" : "CooperativeMatrixUse", + "enumerants" : [ + { + "enumerant" : "MatrixAKHR", + "value" : 0, + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "MatrixBKHR", + "value" : 1, + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + }, + { + "enumerant" : "MatrixAccumulatorKHR", + "value" : 2, + "extensions" : [ "SPV_KHR_cooperative_matrix" ], + "version" : "None" + } + ] + }, { "category" : "Id", "kind" : "IdResultType", diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.cs new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.cs --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.cs 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.cs 2023-08-04 19:44:58.000000000 +0200 @@ -65,6 +65,9 @@ HLSL = 5, CPP_for_OpenCL = 6, SYCL = 7, + HERO_C = 8, + NZSL = 9, + WGSL = 10, } public enum ExecutionModel @@ -352,6 +355,8 @@ Float = 14, UnormInt24 = 15, UnormInt101010_2 = 16, + UnsignedIntRaw10EXT = 19, + UnsignedIntRaw12EXT = 20, } public enum ImageOperandsShift @@ -582,6 +587,7 @@ SingleElementVectorINTEL = 6085, VectorComputeCallableFunctionINTEL = 6087, MediaBlockIOINTEL = 6140, + FPMaxErrorDecorationINTEL = 6170, LatencyControlLabelINTEL = 6172, LatencyControlConstraintINTEL = 6173, ConduitKernelArgumentINTEL = 6175, @@ -1156,6 +1162,7 @@ DotProduct = 6019, DotProductKHR = 6019, RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, BitInstructions = 6025, GroupNonUniformRotateKHR = 6026, AtomicFloat32AddEXT = 6033, @@ -1167,6 +1174,7 @@ BFloat16ConversionINTEL = 6115, SplitBarrierINTEL = 6141, FPGAKernelAttributesv2INTEL = 6161, + FPMaxErrorINTEL = 6169, FPGALatencyControlINTEL = 6171, FPGAArgumentInterfacesINTEL = 6174, GroupUniformArithmeticKHR = 6400, @@ -1277,6 +1285,38 @@ PackedVectorFormat4x8BitKHR = 0, } + public enum CooperativeMatrixOperandsShift + { + MatrixASignedComponentsKHR = 0, + MatrixBSignedComponentsKHR = 1, + MatrixCSignedComponentsKHR = 2, + MatrixResultSignedComponentsKHR = 3, + SaturatingAccumulationKHR = 4, + } + + public enum CooperativeMatrixOperandsMask + { + MaskNone = 0, + MatrixASignedComponentsKHR = 0x00000001, + MatrixBSignedComponentsKHR = 0x00000002, + MatrixCSignedComponentsKHR = 0x00000004, + MatrixResultSignedComponentsKHR = 0x00000008, + SaturatingAccumulationKHR = 0x00000010, + } + + public enum CooperativeMatrixLayout + { + RowMajorKHR = 0, + ColumnMajorKHR = 1, + } + + public enum CooperativeMatrixUse + { + MatrixAKHR = 0, + MatrixBKHR = 1, + MatrixAccumulatorKHR = 2, + } + public enum Op { OpNop = 0, @@ -1651,6 +1691,11 @@ OpUDotAccSatKHR = 4454, OpSUDotAccSat = 4455, OpSUDotAccSatKHR = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.h new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.h --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.h 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.h 2023-08-04 19:44:58.000000000 +0200 @@ -73,6 +73,9 @@ SpvSourceLanguageHLSL = 5, SpvSourceLanguageCPP_for_OpenCL = 6, SpvSourceLanguageSYCL = 7, + SpvSourceLanguageHERO_C = 8, + SpvSourceLanguageNZSL = 9, + SpvSourceLanguageWGSL = 10, SpvSourceLanguageMax = 0x7fffffff, } SpvSourceLanguage; @@ -360,6 +363,8 @@ SpvImageChannelDataTypeFloat = 14, SpvImageChannelDataTypeUnormInt24 = 15, SpvImageChannelDataTypeUnormInt101010_2 = 16, + SpvImageChannelDataTypeUnsignedIntRaw10EXT = 19, + SpvImageChannelDataTypeUnsignedIntRaw12EXT = 20, SpvImageChannelDataTypeMax = 0x7fffffff, } SpvImageChannelDataType; @@ -588,6 +593,7 @@ SpvDecorationSingleElementVectorINTEL = 6085, SpvDecorationVectorComputeCallableFunctionINTEL = 6087, SpvDecorationMediaBlockIOINTEL = 6140, + SpvDecorationFPMaxErrorDecorationINTEL = 6170, SpvDecorationLatencyControlLabelINTEL = 6172, SpvDecorationLatencyControlConstraintINTEL = 6173, SpvDecorationConduitKernelArgumentINTEL = 6175, @@ -1156,6 +1162,7 @@ SpvCapabilityDotProduct = 6019, SpvCapabilityDotProductKHR = 6019, SpvCapabilityRayCullMaskKHR = 6020, + SpvCapabilityCooperativeMatrixKHR = 6022, SpvCapabilityBitInstructions = 6025, SpvCapabilityGroupNonUniformRotateKHR = 6026, SpvCapabilityAtomicFloat32AddEXT = 6033, @@ -1167,6 +1174,7 @@ SpvCapabilityBFloat16ConversionINTEL = 6115, SpvCapabilitySplitBarrierINTEL = 6141, SpvCapabilityFPGAKernelAttributesv2INTEL = 6161, + SpvCapabilityFPMaxErrorINTEL = 6169, SpvCapabilityFPGALatencyControlINTEL = 6171, SpvCapabilityFPGAArgumentInterfacesINTEL = 6174, SpvCapabilityGroupUniformArithmeticKHR = 6400, @@ -1276,6 +1284,37 @@ SpvPackedVectorFormatMax = 0x7fffffff, } SpvPackedVectorFormat; +typedef enum SpvCooperativeMatrixOperandsShift_ { + SpvCooperativeMatrixOperandsMatrixASignedComponentsKHRShift = 0, + SpvCooperativeMatrixOperandsMatrixBSignedComponentsKHRShift = 1, + SpvCooperativeMatrixOperandsMatrixCSignedComponentsKHRShift = 2, + SpvCooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift = 3, + SpvCooperativeMatrixOperandsSaturatingAccumulationKHRShift = 4, + SpvCooperativeMatrixOperandsMax = 0x7fffffff, +} SpvCooperativeMatrixOperandsShift; + +typedef enum SpvCooperativeMatrixOperandsMask_ { + SpvCooperativeMatrixOperandsMaskNone = 0, + SpvCooperativeMatrixOperandsMatrixASignedComponentsKHRMask = 0x00000001, + SpvCooperativeMatrixOperandsMatrixBSignedComponentsKHRMask = 0x00000002, + SpvCooperativeMatrixOperandsMatrixCSignedComponentsKHRMask = 0x00000004, + SpvCooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask = 0x00000008, + SpvCooperativeMatrixOperandsSaturatingAccumulationKHRMask = 0x00000010, +} SpvCooperativeMatrixOperandsMask; + +typedef enum SpvCooperativeMatrixLayout_ { + SpvCooperativeMatrixLayoutRowMajorKHR = 0, + SpvCooperativeMatrixLayoutColumnMajorKHR = 1, + SpvCooperativeMatrixLayoutMax = 0x7fffffff, +} SpvCooperativeMatrixLayout; + +typedef enum SpvCooperativeMatrixUse_ { + SpvCooperativeMatrixUseMatrixAKHR = 0, + SpvCooperativeMatrixUseMatrixBKHR = 1, + SpvCooperativeMatrixUseMatrixAccumulatorKHR = 2, + SpvCooperativeMatrixUseMax = 0x7fffffff, +} SpvCooperativeMatrixUse; + typedef enum SpvOp_ { SpvOpNop = 0, SpvOpUndef = 1, @@ -1649,6 +1688,11 @@ SpvOpUDotAccSatKHR = 4454, SpvOpSUDotAccSat = 4455, SpvOpSUDotAccSatKHR = 4455, + SpvOpTypeCooperativeMatrixKHR = 4456, + SpvOpCooperativeMatrixLoadKHR = 4457, + SpvOpCooperativeMatrixStoreKHR = 4458, + SpvOpCooperativeMatrixMulAddKHR = 4459, + SpvOpCooperativeMatrixLengthKHR = 4460, SpvOpTypeRayQueryKHR = 4472, SpvOpRayQueryInitializeKHR = 4473, SpvOpRayQueryTerminateKHR = 4474, @@ -2367,6 +2411,11 @@ case SpvOpSDotAccSat: *hasResult = true; *hasResultType = true; break; case SpvOpUDotAccSat: *hasResult = true; *hasResultType = true; break; case SpvOpSUDotAccSat: *hasResult = true; *hasResultType = true; break; + case SpvOpTypeCooperativeMatrixKHR: *hasResult = true; *hasResultType = false; break; + case SpvOpCooperativeMatrixLoadKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpCooperativeMatrixStoreKHR: *hasResult = false; *hasResultType = false; break; + case SpvOpCooperativeMatrixMulAddKHR: *hasResult = true; *hasResultType = true; break; + case SpvOpCooperativeMatrixLengthKHR: *hasResult = true; *hasResultType = true; break; case SpvOpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; case SpvOpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; case SpvOpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.hpp new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.hpp --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.hpp 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.hpp 2023-08-04 19:44:58.000000000 +0200 @@ -69,6 +69,9 @@ SourceLanguageHLSL = 5, SourceLanguageCPP_for_OpenCL = 6, SourceLanguageSYCL = 7, + SourceLanguageHERO_C = 8, + SourceLanguageNZSL = 9, + SourceLanguageWGSL = 10, SourceLanguageMax = 0x7fffffff, }; @@ -356,6 +359,8 @@ ImageChannelDataTypeFloat = 14, ImageChannelDataTypeUnormInt24 = 15, ImageChannelDataTypeUnormInt101010_2 = 16, + ImageChannelDataTypeUnsignedIntRaw10EXT = 19, + ImageChannelDataTypeUnsignedIntRaw12EXT = 20, ImageChannelDataTypeMax = 0x7fffffff, }; @@ -584,6 +589,7 @@ DecorationSingleElementVectorINTEL = 6085, DecorationVectorComputeCallableFunctionINTEL = 6087, DecorationMediaBlockIOINTEL = 6140, + DecorationFPMaxErrorDecorationINTEL = 6170, DecorationLatencyControlLabelINTEL = 6172, DecorationLatencyControlConstraintINTEL = 6173, DecorationConduitKernelArgumentINTEL = 6175, @@ -1152,6 +1158,7 @@ CapabilityDotProduct = 6019, CapabilityDotProductKHR = 6019, CapabilityRayCullMaskKHR = 6020, + CapabilityCooperativeMatrixKHR = 6022, CapabilityBitInstructions = 6025, CapabilityGroupNonUniformRotateKHR = 6026, CapabilityAtomicFloat32AddEXT = 6033, @@ -1163,6 +1170,7 @@ CapabilityBFloat16ConversionINTEL = 6115, CapabilitySplitBarrierINTEL = 6141, CapabilityFPGAKernelAttributesv2INTEL = 6161, + CapabilityFPMaxErrorINTEL = 6169, CapabilityFPGALatencyControlINTEL = 6171, CapabilityFPGAArgumentInterfacesINTEL = 6174, CapabilityGroupUniformArithmeticKHR = 6400, @@ -1272,6 +1280,37 @@ PackedVectorFormatMax = 0x7fffffff, }; +enum CooperativeMatrixOperandsShift { + CooperativeMatrixOperandsMatrixASignedComponentsKHRShift = 0, + CooperativeMatrixOperandsMatrixBSignedComponentsKHRShift = 1, + CooperativeMatrixOperandsMatrixCSignedComponentsKHRShift = 2, + CooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift = 3, + CooperativeMatrixOperandsSaturatingAccumulationKHRShift = 4, + CooperativeMatrixOperandsMax = 0x7fffffff, +}; + +enum CooperativeMatrixOperandsMask { + CooperativeMatrixOperandsMaskNone = 0, + CooperativeMatrixOperandsMatrixASignedComponentsKHRMask = 0x00000001, + CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask = 0x00000002, + CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask = 0x00000004, + CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask = 0x00000008, + CooperativeMatrixOperandsSaturatingAccumulationKHRMask = 0x00000010, +}; + +enum CooperativeMatrixLayout { + CooperativeMatrixLayoutRowMajorKHR = 0, + CooperativeMatrixLayoutColumnMajorKHR = 1, + CooperativeMatrixLayoutMax = 0x7fffffff, +}; + +enum CooperativeMatrixUse { + CooperativeMatrixUseMatrixAKHR = 0, + CooperativeMatrixUseMatrixBKHR = 1, + CooperativeMatrixUseMatrixAccumulatorKHR = 2, + CooperativeMatrixUseMax = 0x7fffffff, +}; + enum Op { OpNop = 0, OpUndef = 1, @@ -1645,6 +1684,11 @@ OpUDotAccSatKHR = 4454, OpSUDotAccSat = 4455, OpSUDotAccSatKHR = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, @@ -2363,6 +2407,11 @@ 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 OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; @@ -2745,6 +2794,10 @@ 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 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.hpp11 new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.hpp11 --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.hpp11 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.hpp11 2023-08-04 19:44:58.000000000 +0200 @@ -69,6 +69,9 @@ HLSL = 5, CPP_for_OpenCL = 6, SYCL = 7, + HERO_C = 8, + NZSL = 9, + WGSL = 10, Max = 0x7fffffff, }; @@ -356,6 +359,8 @@ Float = 14, UnormInt24 = 15, UnormInt101010_2 = 16, + UnsignedIntRaw10EXT = 19, + UnsignedIntRaw12EXT = 20, Max = 0x7fffffff, }; @@ -584,6 +589,7 @@ SingleElementVectorINTEL = 6085, VectorComputeCallableFunctionINTEL = 6087, MediaBlockIOINTEL = 6140, + FPMaxErrorDecorationINTEL = 6170, LatencyControlLabelINTEL = 6172, LatencyControlConstraintINTEL = 6173, ConduitKernelArgumentINTEL = 6175, @@ -1152,6 +1158,7 @@ DotProduct = 6019, DotProductKHR = 6019, RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, BitInstructions = 6025, GroupNonUniformRotateKHR = 6026, AtomicFloat32AddEXT = 6033, @@ -1163,6 +1170,7 @@ BFloat16ConversionINTEL = 6115, SplitBarrierINTEL = 6141, FPGAKernelAttributesv2INTEL = 6161, + FPMaxErrorINTEL = 6169, FPGALatencyControlINTEL = 6171, FPGAArgumentInterfacesINTEL = 6174, GroupUniformArithmeticKHR = 6400, @@ -1272,6 +1280,37 @@ 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, + Max = 0x7fffffff, +}; + +enum class CooperativeMatrixUse : unsigned { + MatrixAKHR = 0, + MatrixBKHR = 1, + MatrixAccumulatorKHR = 2, + Max = 0x7fffffff, +}; + enum class Op : unsigned { OpNop = 0, OpUndef = 1, @@ -1645,6 +1684,11 @@ OpUDotAccSatKHR = 4454, OpSUDotAccSat = 4455, OpSUDotAccSatKHR = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, @@ -2363,6 +2407,11 @@ 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::OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break; case Op::OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break; case Op::OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break; @@ -2705,46 +2754,50 @@ // 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)); } +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)); } } // end namespace spv diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.json new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.json --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.json 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.json 2023-08-04 19:44:58.000000000 +0200 @@ -75,7 +75,10 @@ "OpenCL_CPP": 4, "HLSL": 5, "CPP_for_OpenCL": 6, - "SYCL": 7 + "SYCL": 7, + "HERO_C": 8, + "NZSL": 9, + "WGSL": 10 } }, { @@ -395,7 +398,9 @@ "HalfFloat": 13, "Float": 14, "UnormInt24": 15, - "UnormInt101010_2": 16 + "UnormInt101010_2": 16, + "UnsignedIntRaw10EXT": 19, + "UnsignedIntRaw12EXT": 20 } }, { @@ -610,6 +615,7 @@ "SingleElementVectorINTEL": 6085, "VectorComputeCallableFunctionINTEL": 6087, "MediaBlockIOINTEL": 6140, + "FPMaxErrorDecorationINTEL": 6170, "LatencyControlLabelINTEL": 6172, "LatencyControlConstraintINTEL": 6173, "ConduitKernelArgumentINTEL": 6175, @@ -1132,6 +1138,7 @@ "DotProduct": 6019, "DotProductKHR": 6019, "RayCullMaskKHR": 6020, + "CooperativeMatrixKHR": 6022, "BitInstructions": 6025, "GroupNonUniformRotateKHR": 6026, "AtomicFloat32AddEXT": 6033, @@ -1143,6 +1150,7 @@ "BFloat16ConversionINTEL": 6115, "SplitBarrierINTEL": 6141, "FPGAKernelAttributesv2INTEL": 6161, + "FPMaxErrorINTEL": 6169, "FPGALatencyControlINTEL": 6171, "FPGAArgumentInterfacesINTEL": 6174, "GroupUniformArithmeticKHR": 6400 @@ -1259,6 +1267,37 @@ } }, { + "Name": "CooperativeMatrixOperands", + "Type": "Bit", + "Values": + { + "MatrixASignedComponentsKHR": 0, + "MatrixBSignedComponentsKHR": 1, + "MatrixCSignedComponentsKHR": 2, + "MatrixResultSignedComponentsKHR": 3, + "SaturatingAccumulationKHR": 4 + } + }, + { + "Name": "CooperativeMatrixLayout", + "Type": "Value", + "Values": + { + "RowMajorKHR": 0, + "ColumnMajorKHR": 1 + } + }, + { + "Name": "CooperativeMatrixUse", + "Type": "Value", + "Values": + { + "MatrixAKHR": 0, + "MatrixBKHR": 1, + "MatrixAccumulatorKHR": 2 + } + }, + { "Name": "Op", "Type": "Value", "Values": @@ -1635,6 +1674,11 @@ "OpUDotAccSatKHR": 4454, "OpSUDotAccSat": 4455, "OpSUDotAccSatKHR": 4455, + "OpTypeCooperativeMatrixKHR": 4456, + "OpCooperativeMatrixLoadKHR": 4457, + "OpCooperativeMatrixStoreKHR": 4458, + "OpCooperativeMatrixMulAddKHR": 4459, + "OpCooperativeMatrixLengthKHR": 4460, "OpTypeRayQueryKHR": 4472, "OpRayQueryInitializeKHR": 4473, "OpRayQueryTerminateKHR": 4474, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.lua new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.lua --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.lua 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.lua 2023-08-04 19:44:58.000000000 +0200 @@ -60,6 +60,9 @@ HLSL = 5, CPP_for_OpenCL = 6, SYCL = 7, + HERO_C = 8, + NZSL = 9, + WGSL = 10, }, ExecutionModel = { @@ -336,6 +339,8 @@ Float = 14, UnormInt24 = 15, UnormInt101010_2 = 16, + UnsignedIntRaw10EXT = 19, + UnsignedIntRaw12EXT = 20, }, ImageOperandsShift = { @@ -557,6 +562,7 @@ SingleElementVectorINTEL = 6085, VectorComputeCallableFunctionINTEL = 6087, MediaBlockIOINTEL = 6140, + FPMaxErrorDecorationINTEL = 6170, LatencyControlLabelINTEL = 6172, LatencyControlConstraintINTEL = 6173, ConduitKernelArgumentINTEL = 6175, @@ -1114,6 +1120,7 @@ DotProduct = 6019, DotProductKHR = 6019, RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, BitInstructions = 6025, GroupNonUniformRotateKHR = 6026, AtomicFloat32AddEXT = 6033, @@ -1125,6 +1132,7 @@ BFloat16ConversionINTEL = 6115, SplitBarrierINTEL = 6141, FPGAKernelAttributesv2INTEL = 6161, + FPMaxErrorINTEL = 6169, FPGALatencyControlINTEL = 6171, FPGAArgumentInterfacesINTEL = 6174, GroupUniformArithmeticKHR = 6400, @@ -1223,6 +1231,34 @@ PackedVectorFormat4x8BitKHR = 0, }, + CooperativeMatrixOperandsShift = { + MatrixASignedComponentsKHR = 0, + MatrixBSignedComponentsKHR = 1, + MatrixCSignedComponentsKHR = 2, + MatrixResultSignedComponentsKHR = 3, + SaturatingAccumulationKHR = 4, + }, + + CooperativeMatrixOperandsMask = { + MaskNone = 0, + MatrixASignedComponentsKHR = 0x00000001, + MatrixBSignedComponentsKHR = 0x00000002, + MatrixCSignedComponentsKHR = 0x00000004, + MatrixResultSignedComponentsKHR = 0x00000008, + SaturatingAccumulationKHR = 0x00000010, + }, + + CooperativeMatrixLayout = { + RowMajorKHR = 0, + ColumnMajorKHR = 1, + }, + + CooperativeMatrixUse = { + MatrixAKHR = 0, + MatrixBKHR = 1, + MatrixAccumulatorKHR = 2, + }, + Op = { OpNop = 0, OpUndef = 1, @@ -1596,6 +1632,11 @@ OpUDotAccSatKHR = 4454, OpSUDotAccSat = 4455, OpSUDotAccSatKHR = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.py new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.py --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spirv.py 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spirv.py 2023-08-04 19:44:58.000000000 +0200 @@ -60,6 +60,9 @@ 'HLSL' : 5, 'CPP_for_OpenCL' : 6, 'SYCL' : 7, + 'HERO_C' : 8, + 'NZSL' : 9, + 'WGSL' : 10, }, 'ExecutionModel' : { @@ -336,6 +339,8 @@ 'Float' : 14, 'UnormInt24' : 15, 'UnormInt101010_2' : 16, + 'UnsignedIntRaw10EXT' : 19, + 'UnsignedIntRaw12EXT' : 20, }, 'ImageOperandsShift' : { @@ -557,6 +562,7 @@ 'SingleElementVectorINTEL' : 6085, 'VectorComputeCallableFunctionINTEL' : 6087, 'MediaBlockIOINTEL' : 6140, + 'FPMaxErrorDecorationINTEL' : 6170, 'LatencyControlLabelINTEL' : 6172, 'LatencyControlConstraintINTEL' : 6173, 'ConduitKernelArgumentINTEL' : 6175, @@ -1114,6 +1120,7 @@ 'DotProduct' : 6019, 'DotProductKHR' : 6019, 'RayCullMaskKHR' : 6020, + 'CooperativeMatrixKHR' : 6022, 'BitInstructions' : 6025, 'GroupNonUniformRotateKHR' : 6026, 'AtomicFloat32AddEXT' : 6033, @@ -1125,6 +1132,7 @@ 'BFloat16ConversionINTEL' : 6115, 'SplitBarrierINTEL' : 6141, 'FPGAKernelAttributesv2INTEL' : 6161, + 'FPMaxErrorINTEL' : 6169, 'FPGALatencyControlINTEL' : 6171, 'FPGAArgumentInterfacesINTEL' : 6174, 'GroupUniformArithmeticKHR' : 6400, @@ -1223,6 +1231,34 @@ 'PackedVectorFormat4x8BitKHR' : 0, }, + 'CooperativeMatrixOperandsShift' : { + 'MatrixASignedComponentsKHR' : 0, + 'MatrixBSignedComponentsKHR' : 1, + 'MatrixCSignedComponentsKHR' : 2, + 'MatrixResultSignedComponentsKHR' : 3, + 'SaturatingAccumulationKHR' : 4, + }, + + 'CooperativeMatrixOperandsMask' : { + 'MaskNone' : 0, + 'MatrixASignedComponentsKHR' : 0x00000001, + 'MatrixBSignedComponentsKHR' : 0x00000002, + 'MatrixCSignedComponentsKHR' : 0x00000004, + 'MatrixResultSignedComponentsKHR' : 0x00000008, + 'SaturatingAccumulationKHR' : 0x00000010, + }, + + 'CooperativeMatrixLayout' : { + 'RowMajorKHR' : 0, + 'ColumnMajorKHR' : 1, + }, + + 'CooperativeMatrixUse' : { + 'MatrixAKHR' : 0, + 'MatrixBKHR' : 1, + 'MatrixAccumulatorKHR' : 2, + }, + 'Op' : { 'OpNop' : 0, 'OpUndef' : 1, @@ -1596,6 +1632,11 @@ 'OpUDotAccSatKHR' : 4454, 'OpSUDotAccSat' : 4455, 'OpSUDotAccSatKHR' : 4455, + 'OpTypeCooperativeMatrixKHR' : 4456, + 'OpCooperativeMatrixLoadKHR' : 4457, + 'OpCooperativeMatrixStoreKHR' : 4458, + 'OpCooperativeMatrixMulAddKHR' : 4459, + 'OpCooperativeMatrixLengthKHR' : 4460, 'OpTypeRayQueryKHR' : 4472, 'OpRayQueryInitializeKHR' : 4473, 'OpRayQueryTerminateKHR' : 4474, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spv.d new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spv.d --- old/SPIRV-Headers-sdk-1.3.250/include/spirv/unified1/spv.d 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/include/spirv/unified1/spv.d 2023-08-04 19:44:58.000000000 +0200 @@ -68,6 +68,9 @@ HLSL = 5, CPP_for_OpenCL = 6, SYCL = 7, + HERO_C = 8, + NZSL = 9, + WGSL = 10, } enum ExecutionModel : uint @@ -355,6 +358,8 @@ Float = 14, UnormInt24 = 15, UnormInt101010_2 = 16, + UnsignedIntRaw10EXT = 19, + UnsignedIntRaw12EXT = 20, } enum ImageOperandsShift : uint @@ -585,6 +590,7 @@ SingleElementVectorINTEL = 6085, VectorComputeCallableFunctionINTEL = 6087, MediaBlockIOINTEL = 6140, + FPMaxErrorDecorationINTEL = 6170, LatencyControlLabelINTEL = 6172, LatencyControlConstraintINTEL = 6173, ConduitKernelArgumentINTEL = 6175, @@ -1159,6 +1165,7 @@ DotProduct = 6019, DotProductKHR = 6019, RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, BitInstructions = 6025, GroupNonUniformRotateKHR = 6026, AtomicFloat32AddEXT = 6033, @@ -1170,6 +1177,7 @@ BFloat16ConversionINTEL = 6115, SplitBarrierINTEL = 6141, FPGAKernelAttributesv2INTEL = 6161, + FPMaxErrorINTEL = 6169, FPGALatencyControlINTEL = 6171, FPGAArgumentInterfacesINTEL = 6174, GroupUniformArithmeticKHR = 6400, @@ -1280,6 +1288,38 @@ PackedVectorFormat4x8BitKHR = 0, } +enum CooperativeMatrixOperandsShift : uint +{ + MatrixASignedComponentsKHR = 0, + MatrixBSignedComponentsKHR = 1, + MatrixCSignedComponentsKHR = 2, + MatrixResultSignedComponentsKHR = 3, + SaturatingAccumulationKHR = 4, +} + +enum CooperativeMatrixOperandsMask : uint +{ + MaskNone = 0, + MatrixASignedComponentsKHR = 0x00000001, + MatrixBSignedComponentsKHR = 0x00000002, + MatrixCSignedComponentsKHR = 0x00000004, + MatrixResultSignedComponentsKHR = 0x00000008, + SaturatingAccumulationKHR = 0x00000010, +} + +enum CooperativeMatrixLayout : uint +{ + RowMajorKHR = 0, + ColumnMajorKHR = 1, +} + +enum CooperativeMatrixUse : uint +{ + MatrixAKHR = 0, + MatrixBKHR = 1, + MatrixAccumulatorKHR = 2, +} + enum Op : uint { OpNop = 0, @@ -1654,6 +1694,11 @@ OpUDotAccSatKHR = 4454, OpSUDotAccSat = 4455, OpSUDotAccSatKHR = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/bin/makeHeaders new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/bin/makeHeaders --- old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/bin/makeHeaders 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/bin/makeHeaders 2023-08-04 19:44:58.000000000 +0200 @@ -1,5 +1,7 @@ #!/usr/bin/env bash +set -ex + python3 bin/makeExtinstHeaders.py cd ../../include/spirv/unified1 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/header.cpp new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/header.cpp --- old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/header.cpp 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/header.cpp 2023-08-04 19:44:58.000000000 +0200 @@ -574,13 +574,8 @@ // C++ printer class TPrinterCPP : public TPrinterCBase { - private: - void printPrologue(std::ostream& out) const override { - TPrinterCBase::printPrologue(out); - out << "namespace spv {\n\n"; - } - - void printEpilogue(std::ostream& out) const override { + protected: + void printMaskOperators(std::ostream& out, const std::string& specifiers) const { const Json::Value& enums = spvRoot["spv"]["enum"]; out << "// Overload bitwise operators for mask bit combining\n\n"; @@ -593,20 +588,28 @@ const auto typeName = opName + styleStr(enumMask); // Overload operator| - out << "inline " << typeName << " operator|(" << typeName << " a, " << typeName << " b) { return " << + out << specifiers << " " << typeName << " operator|(" << typeName << " a, " << typeName << " b) { return " << typeName << "(unsigned(a) | unsigned(b)); }\n"; // Overload operator& - out << "inline " << typeName << " operator&(" << typeName << " a, " << typeName << " b) { return " << + out << specifiers << " " << typeName << " operator&(" << typeName << " a, " << typeName << " b) { return " << typeName << "(unsigned(a) & unsigned(b)); }\n"; // Overload operator^ - out << "inline " << typeName << " operator^(" << typeName << " a, " << typeName << " b) { return " << + out << specifiers << " " << typeName << " operator^(" << typeName << " a, " << typeName << " b) { return " << typeName << "(unsigned(a) ^ unsigned(b)); }\n"; // Overload operator~ - out << "inline " << typeName << " operator~(" << typeName << " a) { return " << + out << specifiers << " " << typeName << " operator~(" << typeName << " a) { return " << typeName << "(~unsigned(a)); }\n"; } } + } + private: + void printPrologue(std::ostream& out) const override { + TPrinterCBase::printPrologue(out); + out << "namespace spv {\n\n"; + } + void printEpilogue(std::ostream& out) const override { + printMaskOperators(out, "inline"); out << "\n} // end namespace spv\n\n"; out << "#endif // #ifndef spirv_" << headerGuardSuffix() << std::endl; } @@ -642,6 +645,11 @@ // C++11 printer (uses enum classes) class TPrinterCPP11 final : public TPrinterCPP { private: + void printEpilogue(std::ostream& out) const override { + printMaskOperators(out, "constexpr"); + out << "\n} // end namespace spv\n\n"; + out << "#endif // #ifndef spirv_" << headerGuardSuffix() << std::endl; + } std::string enumBeg(const std::string& s, enumStyle_t style) const override { return std::string("enum class ") + s + styleStr(style) + " : unsigned {\n"; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/jsonToSpirv.cpp new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/jsonToSpirv.cpp --- old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/jsonToSpirv.cpp 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/jsonToSpirv.cpp 2023-08-04 19:44:58.000000000 +0200 @@ -88,6 +88,9 @@ EnumValues RayQueryCandidateIntersectionTypeParams; EnumValues FragmentShadingRateParams; EnumValues PackedVectorFormatParams; +EnumValues CooperativeMatrixOperandsParams; +EnumValues CooperativeMatrixLayoutParams; +EnumValues CooperativeMatrixUseParams; std::pair<bool, std::string> ReadFile(const std::string& path) { @@ -158,6 +161,8 @@ type = OperandLiteralNumber; } else if (operandKind == "LiteralContextDependentNumber") { type = OperandAnySizeLiteralNumber; + } else if (operandKind == "LiteralFloat") { + type = OperandLiteralNumber; } else if (operandKind == "SourceLanguage") { type = OperandSource; } else if (operandKind == "ExecutionModel") { @@ -234,6 +239,12 @@ type = OperandFragmentShadingRate; } else if (operandKind == "PackedVectorFormat") { type = OperandPackedVectorFormat; + } else if (operandKind == "CooperativeMatrixOperands") { + type = OperandCooperativeMatrixOperands; + } else if (operandKind == "CooperativeMatrixLayout") { + type = OperandCooperativeMatrixLayout; + } else if (operandKind == "CooperativeMatrixUse") { + type = OperandCooperativeMatrixUse; } if (type == OperandNone) { @@ -544,6 +555,12 @@ establishOperandClass(enumName, OperandFragmentShadingRate, &FragmentShadingRateParams, operandEnum, category); } else if (enumName == "PackedVectorFormat") { establishOperandClass(enumName, OperandPackedVectorFormat, &PackedVectorFormatParams, operandEnum, category); + } else if (enumName == "CooperativeMatrixOperands") { + establishOperandClass(enumName, OperandCooperativeMatrixOperands, &CooperativeMatrixOperandsParams, operandEnum, category); + } else if (enumName == "CooperativeMatrixLayout") { + establishOperandClass(enumName, OperandCooperativeMatrixLayout, &CooperativeMatrixLayoutParams, operandEnum, category); + } else if (enumName == "CooperativeMatrixUse") { + establishOperandClass(enumName, OperandCooperativeMatrixUse, &CooperativeMatrixUseParams, operandEnum, category); } } } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/jsonToSpirv.h new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/jsonToSpirv.h --- old/SPIRV-Headers-sdk-1.3.250/tools/buildHeaders/jsonToSpirv.h 2023-05-03 23:12:01.000000000 +0200 +++ new/SPIRV-Headers-sdk-1.3.261/tools/buildHeaders/jsonToSpirv.h 2023-08-04 19:44:58.000000000 +0200 @@ -96,6 +96,9 @@ OperandQuantizationModes, OperandOverflowModes, OperandPackedVectorFormat, + OperandCooperativeMatrixOperands, + OperandCooperativeMatrixLayout, + OperandCooperativeMatrixUse, OperandOpcode,
