diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 83fd29649..fce5c0e56 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -136,8 +136,8 @@ jobs: fail-fast: true matrix: include: [ - { runs-on: macos-14, arch: osx-arm64, bindir: osx-arm64, config: debug, binsuffix: Debug }, - { runs-on: macos-14, arch: osx-arm64, bindir: osx-arm64, config: release, binsuffix: Release }, + { runs-on: macos-15, arch: osx-arm64, bindir: osx-arm64, config: debug, binsuffix: Debug }, + { runs-on: macos-15, arch: osx-arm64, bindir: osx-arm64, config: release, binsuffix: Release }, ] name: osx-${{ matrix.arch }}-${{ matrix.config }} runs-on: ${{ matrix.runs-on }} @@ -156,6 +156,8 @@ jobs: with: repository: bkaradzic/bimg path: bimg + - name: Select Xcode + run: sudo xcode-select -s /Applications/Xcode_16.2.app - name: Build run: | cd bgfx diff --git a/3rdparty/dawn/LICENSE b/3rdparty/dawn/LICENSE index 5b716b6a0..08e7ccc4f 100644 --- a/3rdparty/dawn/LICENSE +++ b/3rdparty/dawn/LICENSE @@ -1,4 +1,6 @@ -// Copyright 2017-2023 The Dawn & Tint Authors +Files: * + +// Copyright 2017-2026 The Dawn & Tint Authors // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -24,3 +26,185 @@ // 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. + +------------------ + +Files: generator/templates/art/* +Files: tools/android/webgpu/* + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/3rdparty/dawn/include/tint/tint.h b/3rdparty/dawn/include/tint/tint.h index 3fa925dff..b06148833 100644 --- a/3rdparty/dawn/include/tint/tint.h +++ b/3rdparty/dawn/include/tint/tint.h @@ -35,6 +35,7 @@ // headers will need to be moved to include/tint/. #include "src/tint/api/common/binding_point.h" // IWYU pragma: export +#include "src/tint/api/common/bindings.h" // IWYU pragma: export #include "src/tint/api/common/resource_type.h" // IWYU pragma: export #include "src/tint/api/common/subgroup_matrix.h" // IWYU pragma: export #include "src/tint/api/common/substitute_overrides_config.h" // IWYU pragma: export diff --git a/3rdparty/dawn/include/webgpu/webgpu.h b/3rdparty/dawn/include/webgpu/webgpu.h index dddbd3ac0..2d860a2ed 100644 --- a/3rdparty/dawn/include/webgpu/webgpu.h +++ b/3rdparty/dawn/include/webgpu/webgpu.h @@ -125,6 +125,7 @@ typedef struct WGPUBindGroupLayoutImpl* WGPUBindGroupLayout WGPU_OBJECT_ATTRIBUT typedef struct WGPUBufferImpl* WGPUBuffer WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUCommandBufferImpl* WGPUCommandBuffer WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUCommandEncoderImpl* WGPUCommandEncoder WGPU_OBJECT_ATTRIBUTE; +typedef struct WGPUComputePassEncoderImpl* WGPUComputePassEncoder WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUComputePipelineImpl* WGPUComputePipeline WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUDeviceImpl* WGPUDevice WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUExternalTextureImpl* WGPUExternalTexture WGPU_OBJECT_ATTRIBUTE; @@ -133,6 +134,8 @@ typedef struct WGPUPipelineLayoutImpl* WGPUPipelineLayout WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUQuerySetImpl* WGPUQuerySet WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUQueueImpl* WGPUQueue WGPU_OBJECT_ATTRIBUTE; typedef struct WGPURenderBundleImpl* WGPURenderBundle WGPU_OBJECT_ATTRIBUTE; +typedef struct WGPURenderBundleEncoderImpl* WGPURenderBundleEncoder WGPU_OBJECT_ATTRIBUTE; +typedef struct WGPURenderPassEncoderImpl* WGPURenderPassEncoder WGPU_OBJECT_ATTRIBUTE; typedef struct WGPURenderPipelineImpl* WGPURenderPipeline WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUResourceTableImpl* WGPUResourceTable WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUSamplerImpl* WGPUSampler WGPU_OBJECT_ATTRIBUTE; @@ -144,13 +147,10 @@ typedef struct WGPUSurfaceImpl* WGPUSurface WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUTexelBufferViewImpl* WGPUTexelBufferView WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUTextureImpl* WGPUTexture WGPU_OBJECT_ATTRIBUTE; typedef struct WGPUTextureViewImpl* WGPUTextureView WGPU_OBJECT_ATTRIBUTE; -typedef struct WGPUComputePassEncoderImpl* WGPUComputePassEncoder WGPU_OBJECT_ATTRIBUTE; -typedef struct WGPURenderBundleEncoderImpl* WGPURenderBundleEncoder WGPU_OBJECT_ATTRIBUTE; -typedef struct WGPURenderPassEncoderImpl* WGPURenderPassEncoder WGPU_OBJECT_ATTRIBUTE; // Structure forward declarations struct WGPUAdapterPropertiesD3D; -struct WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs; +struct WGPUAdapterPropertiesDrm; struct WGPUAdapterPropertiesVk; struct WGPUAdapterPropertiesWGPU; struct WGPUBindingResource; @@ -158,6 +158,7 @@ struct WGPUBlendComponent; struct WGPUBufferBindingLayout; struct WGPUBufferHostMappedPointer; struct WGPUColor; +struct WGPUColorSpaceDawn; struct WGPUColorTargetStateExpandResolveTextureDawn; struct WGPUCommandBufferDescriptor; struct WGPUCompatibilityModeLimits; @@ -203,7 +204,6 @@ struct WGPUQueueDescriptor; struct WGPURenderBundleDescriptor; struct WGPURenderBundleEncoderDescriptor; struct WGPURenderPassDepthStencilAttachment; -struct WGPURenderPassDescriptorExpandResolveRect; struct WGPURenderPassDescriptorResolveRect; struct WGPURenderPassMaxDrawCount; struct WGPURequestAdapterWebGPUBackendOptions; @@ -214,7 +214,7 @@ struct WGPUShaderModuleCompilationOptions; struct WGPUShaderSourceSPIRV; struct WGPUShaderSourceWGSL; struct WGPUSharedBufferMemoryBeginAccessDescriptor; -struct WGPUSharedBufferMemoryDescriptor; +struct WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor; struct WGPUSharedBufferMemoryEndAccessState; struct WGPUSharedBufferMemoryProperties; struct WGPUSharedFenceDXGISharedHandleDescriptor; @@ -266,7 +266,7 @@ struct WGPUTexelBufferBindingLayout; struct WGPUTexelBufferViewDescriptor; struct WGPUTexelCopyBufferLayout; struct WGPUTextureBindingLayout; -struct WGPUTextureBindingViewDimensionDescriptor; +struct WGPUTextureBindingViewDimension; struct WGPUTextureComponentSwizzle; struct WGPUVertexAttribute; struct WGPUYCbCrVkDescriptor; @@ -290,10 +290,12 @@ struct WGPUInstanceDescriptor; struct WGPULimits; struct WGPUPipelineLayoutPixelLocalStorage; struct WGPURenderPassColorAttachment; +struct WGPURenderPassRenderAreaRect; struct WGPURenderPassStorageAttachment; struct WGPURequestAdapterOptions; struct WGPUSamplerDescriptor; struct WGPUShaderModuleDescriptor; +struct WGPUSharedBufferMemoryDescriptor; struct WGPUSharedFenceDescriptor; struct WGPUSharedFenceExportInfo; struct WGPUSharedTextureMemoryAHardwareBufferProperties; @@ -330,6 +332,8 @@ struct WGPUBufferMapCallbackInfo; struct WGPUCompilationInfoCallbackInfo; struct WGPUCreateComputePipelineAsyncCallbackInfo; struct WGPUCreateRenderPipelineAsyncCallbackInfo; +struct WGPUDawnLoadCacheDataCallbackInfo; +struct WGPUDawnStoreCacheDataCallbackInfo; struct WGPUDeviceLostCallbackInfo; struct WGPULoggingCallbackInfo; struct WGPUPopErrorScopeCallbackInfo; @@ -429,6 +433,40 @@ typedef enum WGPUCallbackMode { WGPUCallbackMode_Force32 = 0x7FFFFFFF } WGPUCallbackMode WGPU_ENUM_ATTRIBUTE; +typedef enum WGPUColorSpacePrimariesDawn { + WGPUColorSpacePrimariesDawn_SRGB = 0x00000001, + WGPUColorSpacePrimariesDawn_Rec709 = 0x00000001, + WGPUColorSpacePrimariesDawn_Rec601 = 0x00000002, + WGPUColorSpacePrimariesDawn_Rec2020 = 0x00000003, + WGPUColorSpacePrimariesDawn_DisplayP3 = 0x00000004, + WGPUColorSpacePrimariesDawn_Force32 = 0x7FFFFFFF +} WGPUColorSpacePrimariesDawn WGPU_ENUM_ATTRIBUTE; + +typedef enum WGPUColorSpaceTransferDawn { + WGPUColorSpaceTransferDawn_Identity = 0x00000001, + WGPUColorSpaceTransferDawn_SRGB = 0x00000002, + WGPUColorSpaceTransferDawn_DisplayP3 = 0x00000003, + WGPUColorSpaceTransferDawn_SMPTE_170M = 0x00000004, + WGPUColorSpaceTransferDawn_HLG = 0x00000005, + WGPUColorSpaceTransferDawn_PQ = 0x00000006, + WGPUColorSpaceTransferDawn_Force32 = 0x7FFFFFFF +} WGPUColorSpaceTransferDawn WGPU_ENUM_ATTRIBUTE; + +typedef enum WGPUColorSpaceYCbCrMatrixDawn { + WGPUColorSpaceYCbCrMatrixDawn_Identity = 0x00000001, + WGPUColorSpaceYCbCrMatrixDawn_Rec601 = 0x00000002, + WGPUColorSpaceYCbCrMatrixDawn_Rec709 = 0x00000003, + WGPUColorSpaceYCbCrMatrixDawn_Rec2020 = 0x00000004, + WGPUColorSpaceYCbCrMatrixDawn_Force32 = 0x7FFFFFFF +} WGPUColorSpaceYCbCrMatrixDawn WGPU_ENUM_ATTRIBUTE; + +typedef enum WGPUColorSpaceYCbCrRangeDawn { + WGPUColorSpaceYCbCrRangeDawn_Identity = 0x00000001, + WGPUColorSpaceYCbCrRangeDawn_Narrow = 0x00000002, + WGPUColorSpaceYCbCrRangeDawn_Full = 0x00000003, + WGPUColorSpaceYCbCrRangeDawn_Force32 = 0x7FFFFFFF +} WGPUColorSpaceYCbCrRangeDawn WGPU_ENUM_ATTRIBUTE; + typedef enum WGPUCompareFunction { WGPUCompareFunction_Undefined = 0x00000000, WGPUCompareFunction_Never = 0x00000001, @@ -611,9 +649,13 @@ typedef enum WGPUFeatureName { WGPUFeatureName_SharedBufferMemoryD3D12SharedMemoryFileMappingHandle = 0x00050038, WGPUFeatureName_SharedTextureMemoryD3D12Resource = 0x00050039, WGPUFeatureName_ChromiumExperimentalSamplingResourceTable = 0x0005003A, - WGPUFeatureName_ChromiumExperimentalSubgroupSizeControl = 0x0005003B, + WGPUFeatureName_SubgroupSizeControl = 0x0005003B, WGPUFeatureName_AtomicVec2uMinMax = 0x0005003C, WGPUFeatureName_Unorm16FormatsForExternalTexture = 0x0005003D, + WGPUFeatureName_OpaqueYCbCrAndroidForExternalTexture = 0x0005003E, + WGPUFeatureName_Unorm16Filterable = 0x0005003F, + WGPUFeatureName_RenderPassRenderArea = 0x00050040, + WGPUFeatureName_AdapterPropertiesDrm = 0x00050041, WGPUFeatureName_Force32 = 0x7FFFFFFF } WGPUFeatureName WGPU_ENUM_ATTRIBUTE; @@ -700,6 +742,9 @@ typedef enum WGPUPowerPreference { typedef enum WGPUPredefinedColorSpace { WGPUPredefinedColorSpace_SRGB = 0x00000001, WGPUPredefinedColorSpace_DisplayP3 = 0x00000002, + WGPUPredefinedColorSpace_SRGBLinear = 0x00050003, + WGPUPredefinedColorSpace_DisplayP3Linear = 0x00050004, + WGPUPredefinedColorSpace_Rec2020Linear = 0x00050005, WGPUPredefinedColorSpace_Force32 = 0x7FFFFFFF } WGPUPredefinedColorSpace WGPU_ENUM_ATTRIBUTE; @@ -817,12 +862,12 @@ typedef enum WGPUSType { WGPUSType_SurfaceColorManagement = 0x0000000A, WGPUSType_RequestAdapterWebXROptions = 0x0000000B, WGPUSType_TextureComponentSwizzleDescriptor = 0x0000000C, - WGPUSType_CompatibilityModeLimits = 0x00020000, - WGPUSType_TextureBindingViewDimensionDescriptor = 0x00020001, + WGPUSType_ExternalTextureBindingLayout = 0x0000000D, + WGPUSType_ExternalTextureBindingEntry = 0x0000000E, + WGPUSType_CompatibilityModeLimits = 0x0000000F, + WGPUSType_TextureBindingViewDimension = 0x00000010, WGPUSType_EmscriptenSurfaceSourceCanvasHTMLSelector = 0x00040000, WGPUSType_SurfaceDescriptorFromWindowsCoreWindow = 0x00050000, - WGPUSType_ExternalTextureBindingEntry = 0x00050001, - WGPUSType_ExternalTextureBindingLayout = 0x00050002, WGPUSType_SurfaceDescriptorFromWindowsUWPSwapChainPanel = 0x00050003, WGPUSType_DawnTextureInternalUsageDescriptor = 0x00050004, WGPUSType_DawnEncoderInternalUsageDescriptor = 0x00050005, @@ -847,7 +892,7 @@ typedef enum WGPUSType { WGPUSType_DawnDrmFormatCapabilities = 0x00050018, WGPUSType_ShaderModuleCompilationOptions = 0x00050019, WGPUSType_ColorTargetStateExpandResolveTextureDawn = 0x0005001A, - WGPUSType_RenderPassDescriptorExpandResolveRect = 0x0005001B, + WGPUSType_RenderPassRenderAreaRect = 0x0005001B, WGPUSType_SharedTextureMemoryVkDedicatedAllocationDescriptor = 0x0005001C, WGPUSType_SharedTextureMemoryAHardwareBufferDescriptor = 0x0005001D, WGPUSType_SharedTextureMemoryDmaBufDescriptor = 0x0005001E, @@ -900,7 +945,7 @@ typedef enum WGPUSType { WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor = 0x0005004E, WGPUSType_RequestAdapterOptionsAngleVirtualizationGroup = 0x0005004F, WGPUSType_PipelineLayoutResourceTable = 0x00050050, - WGPUSType_AdapterPropertiesExplicitComputeSubgroupSizeConfigs = 0x00050051, + WGPUSType_AdapterPropertiesDrm = 0x00050051, WGPUSType_Force32 = 0x7FFFFFFF } WGPUSType WGPU_ENUM_ATTRIBUTE; @@ -1060,7 +1105,6 @@ typedef enum WGPUTextureFormat { WGPUTextureFormat_R8BG8Biplanar444Unorm = 0x00050004, WGPUTextureFormat_R10X6BG10X6Biplanar422Unorm = 0x00050005, WGPUTextureFormat_R10X6BG10X6Biplanar444Unorm = 0x00050006, - WGPUTextureFormat_External = 0x00050007, WGPUTextureFormat_OpaqueYCbCrAndroid = 0x00050007, WGPUTextureFormat_Force32 = 0x7FFFFFFF } WGPUTextureFormat WGPU_ENUM_ATTRIBUTE; @@ -1160,6 +1204,10 @@ typedef enum WGPUWGSLLanguageFeatureName { WGPUWGSLLanguageFeatureName_UniformBufferStandardLayout = 0x00000005, WGPUWGSLLanguageFeatureName_SubgroupId = 0x00000006, WGPUWGSLLanguageFeatureName_TextureAndSamplerLet = 0x00000007, + WGPUWGSLLanguageFeatureName_SubgroupUniformity = 0x00000008, + WGPUWGSLLanguageFeatureName_TextureFormatsTier1 = 0x00000009, + WGPUWGSLLanguageFeatureName_LinearIndexing = 0x0000000A, + WGPUWGSLLanguageFeatureName_ImmediateAddressSpace = 0x0000000B, WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented = 0x00050000, WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental = 0x00050001, WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental = 0x00050002, @@ -1169,12 +1217,8 @@ typedef enum WGPUWGSLLanguageFeatureName { WGPUWGSLLanguageFeatureName_TexelBuffers = 0x00050006, WGPUWGSLLanguageFeatureName_ChromiumPrint = 0x00050007, WGPUWGSLLanguageFeatureName_FragmentDepth = 0x00050008, - WGPUWGSLLanguageFeatureName_ImmediateAddressSpace = 0x00050009, - WGPUWGSLLanguageFeatureName_SubgroupUniformity = 0x0005000A, - WGPUWGSLLanguageFeatureName_BufferView = 0x0005000B, - WGPUWGSLLanguageFeatureName_FilteringParameters = 0x0005000C, - WGPUWGSLLanguageFeatureName_SwizzleAssignment = 0x0005000D, - WGPUWGSLLanguageFeatureName_LinearIndexing = 0x0005000E, + WGPUWGSLLanguageFeatureName_BufferView = 0x00050009, + WGPUWGSLLanguageFeatureName_SwizzleAssignment = 0x0005000A, WGPUWGSLLanguageFeatureName_Force32 = 0x7FFFFFFF } WGPUWGSLLanguageFeatureName WGPU_ENUM_ATTRIBUTE; @@ -1243,6 +1287,10 @@ typedef void (*WGPUCreateComputePipelineAsyncCallback)(WGPUCreatePipelineAsyncSt typedef void (*WGPUCreateRenderPipelineAsyncCallback)(WGPUCreatePipelineAsyncStatus status, WGPURenderPipeline pipeline, WGPUStringView message, WGPU_NULLABLE void* userdata1, WGPU_NULLABLE void* userdata2) WGPU_FUNCTION_ATTRIBUTE; +typedef size_t (*WGPUDawnLoadCacheDataCallback)(size_t keySize, uint8_t const * key, size_t valueSize, uint8_t * value, WGPU_NULLABLE void* userdata1, WGPU_NULLABLE void* userdata2) WGPU_FUNCTION_ATTRIBUTE; + +typedef void (*WGPUDawnStoreCacheDataCallback)(size_t keySize, uint8_t const * key, size_t valueSize, uint8_t const * value, WGPU_NULLABLE void* userdata1, WGPU_NULLABLE void* userdata2) WGPU_FUNCTION_ATTRIBUTE; + typedef void (*WGPUDeviceLostCallback)(WGPUDevice const * device, WGPUDeviceLostReason reason, WGPUStringView message, WGPU_NULLABLE void* userdata1, WGPU_NULLABLE void* userdata2) WGPU_FUNCTION_ATTRIBUTE; typedef void (*WGPULoggingCallback)(WGPULoggingType type, WGPUStringView message, WGPU_NULLABLE void* userdata1, WGPU_NULLABLE void* userdata2) WGPU_FUNCTION_ATTRIBUTE; @@ -1326,6 +1374,34 @@ typedef struct WGPUCreateRenderPipelineAsyncCallbackInfo { /*.userdata2=*/NULL _wgpu_COMMA \ }) +typedef struct WGPUDawnLoadCacheDataCallbackInfo { + WGPUChainedStruct * nextInChain; + WGPUDawnLoadCacheDataCallback callback; + WGPU_NULLABLE void* userdata1; + WGPU_NULLABLE void* userdata2; +} WGPUDawnLoadCacheDataCallbackInfo WGPU_STRUCTURE_ATTRIBUTE; + +#define WGPU_DAWN_LOAD_CACHE_DATA_CALLBACK_INFO_INIT _wgpu_MAKE_INIT_STRUCT(WGPUDawnLoadCacheDataCallbackInfo, { \ + /*.nextInChain=*/NULL _wgpu_COMMA \ + /*.callback=*/NULL _wgpu_COMMA \ + /*.userdata1=*/NULL _wgpu_COMMA \ + /*.userdata2=*/NULL _wgpu_COMMA \ +}) + +typedef struct WGPUDawnStoreCacheDataCallbackInfo { + WGPUChainedStruct * nextInChain; + WGPUDawnStoreCacheDataCallback callback; + WGPU_NULLABLE void* userdata1; + WGPU_NULLABLE void* userdata2; +} WGPUDawnStoreCacheDataCallbackInfo WGPU_STRUCTURE_ATTRIBUTE; + +#define WGPU_DAWN_STORE_CACHE_DATA_CALLBACK_INFO_INIT _wgpu_MAKE_INIT_STRUCT(WGPUDawnStoreCacheDataCallbackInfo, { \ + /*.nextInChain=*/NULL _wgpu_COMMA \ + /*.callback=*/NULL _wgpu_COMMA \ + /*.userdata1=*/NULL _wgpu_COMMA \ + /*.userdata2=*/NULL _wgpu_COMMA \ +}) + typedef struct WGPUDeviceLostCallbackInfo { WGPUChainedStruct * nextInChain; WGPUCallbackMode mode; @@ -1449,21 +1525,27 @@ typedef struct WGPUAdapterPropertiesD3D { }) // Can be chained in WGPUAdapterInfo -typedef struct WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs { +typedef struct WGPUAdapterPropertiesDrm { WGPUChainedStruct chain; - uint32_t minExplicitComputeSubgroupSize; - uint32_t maxExplicitComputeSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; -} WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs WGPU_STRUCTURE_ATTRIBUTE; + WGPUBool hasPrimary; + WGPUBool hasRender; + uint64_t primaryMajor; + uint64_t primaryMinor; + uint64_t renderMajor; + uint64_t renderMinor; +} WGPUAdapterPropertiesDrm WGPU_STRUCTURE_ATTRIBUTE; -#define WGPU_ADAPTER_PROPERTIES_EXPLICIT_COMPUTE_SUBGROUP_SIZE_CONFIGS_INIT _wgpu_MAKE_INIT_STRUCT(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, { \ +#define WGPU_ADAPTER_PROPERTIES_DRM_INIT _wgpu_MAKE_INIT_STRUCT(WGPUAdapterPropertiesDrm, { \ /*.chain=*/_wgpu_MAKE_INIT_STRUCT(WGPUChainedStruct, { \ /*.next=*/NULL _wgpu_COMMA \ - /*.sType=*/WGPUSType_AdapterPropertiesExplicitComputeSubgroupSizeConfigs _wgpu_COMMA \ + /*.sType=*/WGPUSType_AdapterPropertiesDrm _wgpu_COMMA \ }) _wgpu_COMMA \ - /*.minExplicitComputeSubgroupSize=*/0 _wgpu_COMMA \ - /*.maxExplicitComputeSubgroupSize=*/0 _wgpu_COMMA \ - /*.maxComputeWorkgroupSubgroups=*/0 _wgpu_COMMA \ + /*.hasPrimary=*/WGPU_FALSE _wgpu_COMMA \ + /*.hasRender=*/WGPU_FALSE _wgpu_COMMA \ + /*.primaryMajor=*/0 _wgpu_COMMA \ + /*.primaryMinor=*/0 _wgpu_COMMA \ + /*.renderMajor=*/0 _wgpu_COMMA \ + /*.renderMinor=*/0 _wgpu_COMMA \ }) // Can be chained in WGPUAdapterInfo @@ -1570,6 +1652,24 @@ typedef struct WGPUColor { /*.a=*/0. _wgpu_COMMA \ }) +typedef struct WGPUColorSpaceDawn { + WGPUChainedStruct * nextInChain; + WGPUColorSpacePrimariesDawn primaries; + WGPUColorSpaceTransferDawn transfer; + WGPUColorSpaceYCbCrRangeDawn yCbCrRange; + WGPUColorSpaceYCbCrMatrixDawn yCbCrMatrix; + float hdrReferenceWhiteLuminance; +} WGPUColorSpaceDawn WGPU_STRUCTURE_ATTRIBUTE; + +#define WGPU_COLOR_SPACE_DAWN_INIT _wgpu_MAKE_INIT_STRUCT(WGPUColorSpaceDawn, { \ + /*.nextInChain=*/NULL _wgpu_COMMA \ + /*.primaries=*/_wgpu_ENUM_ZERO_INIT(WGPUColorSpacePrimariesDawn) _wgpu_COMMA \ + /*.transfer=*/WGPUColorSpaceTransferDawn_Identity _wgpu_COMMA \ + /*.yCbCrRange=*/WGPUColorSpaceYCbCrRangeDawn_Identity _wgpu_COMMA \ + /*.yCbCrMatrix=*/WGPUColorSpaceYCbCrMatrixDawn_Identity _wgpu_COMMA \ + /*.hdrReferenceWhiteLuminance=*/0 _wgpu_COMMA \ +}) + // Can be chained in WGPUColorTargetState typedef struct WGPUColorTargetStateExpandResolveTextureDawn { WGPUChainedStruct chain; @@ -1685,6 +1785,8 @@ typedef struct WGPUDawnCacheDeviceDescriptor { WGPUDawnLoadCacheDataFunction loadDataFunction; WGPUDawnStoreCacheDataFunction storeDataFunction; void * functionUserdata; + WGPUDawnLoadCacheDataCallbackInfo dawnLoadCacheDataCallbackInfo; + WGPUDawnStoreCacheDataCallbackInfo dawnStoreCacheDataCallbackInfo; } WGPUDawnCacheDeviceDescriptor WGPU_STRUCTURE_ATTRIBUTE; #define WGPU_DAWN_CACHE_DEVICE_DESCRIPTOR_INIT _wgpu_MAKE_INIT_STRUCT(WGPUDawnCacheDeviceDescriptor, { \ @@ -1696,6 +1798,8 @@ typedef struct WGPUDawnCacheDeviceDescriptor { /*.loadDataFunction=*/NULL _wgpu_COMMA \ /*.storeDataFunction=*/NULL _wgpu_COMMA \ /*.functionUserdata=*/nullptr _wgpu_COMMA \ + /*.dawnLoadCacheDataCallbackInfo=*/WGPU_DAWN_LOAD_CACHE_DATA_CALLBACK_INFO_INIT _wgpu_COMMA \ + /*.dawnStoreCacheDataCallbackInfo=*/WGPU_DAWN_STORE_CACHE_DATA_CALLBACK_INFO_INIT _wgpu_COMMA \ }) // Can be chained in WGPUCompilationMessage @@ -2211,26 +2315,6 @@ typedef struct WGPURenderPassDepthStencilAttachment { /*.stencilReadOnly=*/WGPU_FALSE _wgpu_COMMA \ }) -// Can be chained in WGPURenderPassDescriptor -typedef struct WGPURenderPassDescriptorExpandResolveRect { - WGPUChainedStruct chain; - uint32_t x; - uint32_t y; - uint32_t width; - uint32_t height; -} WGPURenderPassDescriptorExpandResolveRect WGPU_STRUCTURE_ATTRIBUTE; - -#define WGPU_RENDER_PASS_DESCRIPTOR_EXPAND_RESOLVE_RECT_INIT _wgpu_MAKE_INIT_STRUCT(WGPURenderPassDescriptorExpandResolveRect, { \ - /*.chain=*/_wgpu_MAKE_INIT_STRUCT(WGPUChainedStruct, { \ - /*.next=*/NULL _wgpu_COMMA \ - /*.sType=*/WGPUSType_RenderPassDescriptorExpandResolveRect _wgpu_COMMA \ - }) _wgpu_COMMA \ - /*.x=*/0 _wgpu_COMMA \ - /*.y=*/0 _wgpu_COMMA \ - /*.width=*/0 _wgpu_COMMA \ - /*.height=*/0 _wgpu_COMMA \ -}) - // Can be chained in WGPURenderPassDescriptor typedef struct WGPURenderPassDescriptorResolveRect { WGPUChainedStruct chain; @@ -2366,6 +2450,7 @@ typedef struct WGPUSharedBufferMemoryBeginAccessDescriptor { WGPUBool initialized; size_t fenceCount; WGPUSharedFence const * fences; + size_t signaledValueCount; uint64_t const * signaledValues; } WGPUSharedBufferMemoryBeginAccessDescriptor WGPU_STRUCTURE_ATTRIBUTE; @@ -2374,17 +2459,24 @@ typedef struct WGPUSharedBufferMemoryBeginAccessDescriptor { /*.initialized=*/WGPU_FALSE _wgpu_COMMA \ /*.fenceCount=*/0 _wgpu_COMMA \ /*.fences=*/NULL _wgpu_COMMA \ + /*.signaledValueCount=*/0 _wgpu_COMMA \ /*.signaledValues=*/NULL _wgpu_COMMA \ }) -typedef struct WGPUSharedBufferMemoryDescriptor { - WGPUChainedStruct * nextInChain; - WGPUStringView label; -} WGPUSharedBufferMemoryDescriptor WGPU_STRUCTURE_ATTRIBUTE; +// Can be chained in WGPUSharedBufferMemoryDescriptor +typedef struct WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor { + WGPUChainedStruct chain; + void * handle; + uint64_t size; +} WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor WGPU_STRUCTURE_ATTRIBUTE; -#define WGPU_SHARED_BUFFER_MEMORY_DESCRIPTOR_INIT _wgpu_MAKE_INIT_STRUCT(WGPUSharedBufferMemoryDescriptor, { \ - /*.nextInChain=*/NULL _wgpu_COMMA \ - /*.label=*/WGPU_STRING_VIEW_INIT _wgpu_COMMA \ +#define WGPU_SHARED_BUFFER_MEMORY_D3D12_SHARED_MEMORY_FILE_MAPPING_HANDLE_DESCRIPTOR_INIT _wgpu_MAKE_INIT_STRUCT(WGPUSharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor, { \ + /*.chain=*/_wgpu_MAKE_INIT_STRUCT(WGPUChainedStruct, { \ + /*.next=*/NULL _wgpu_COMMA \ + /*.sType=*/WGPUSType_SharedBufferMemoryD3D12SharedMemoryFileMappingHandleDescriptor _wgpu_COMMA \ + }) _wgpu_COMMA \ + /*.handle=*/NULL _wgpu_COMMA \ + /*.size=*/0 _wgpu_COMMA \ }) typedef struct WGPUSharedBufferMemoryEndAccessState { @@ -2392,6 +2484,7 @@ typedef struct WGPUSharedBufferMemoryEndAccessState { WGPUBool initialized; size_t fenceCount; WGPUSharedFence const * fences; + size_t signaledValueCount; uint64_t const * signaledValues; } WGPUSharedBufferMemoryEndAccessState WGPU_STRUCTURE_ATTRIBUTE; @@ -2400,6 +2493,7 @@ typedef struct WGPUSharedBufferMemoryEndAccessState { /*.initialized=*/WGPU_FALSE _wgpu_COMMA \ /*.fenceCount=*/0 _wgpu_COMMA \ /*.fences=*/NULL _wgpu_COMMA \ + /*.signaledValueCount=*/0 _wgpu_COMMA \ /*.signaledValues=*/NULL _wgpu_COMMA \ }) @@ -2587,7 +2681,6 @@ typedef struct WGPUSharedFenceVkSemaphoreZirconHandleExportInfo { typedef struct WGPUSharedTextureMemoryAHardwareBufferDescriptor { WGPUChainedStruct chain; void * handle; - WGPUBool useExternalFormat; } WGPUSharedTextureMemoryAHardwareBufferDescriptor WGPU_STRUCTURE_ATTRIBUTE; #define WGPU_SHARED_TEXTURE_MEMORY_A_HARDWARE_BUFFER_DESCRIPTOR_INIT _wgpu_MAKE_INIT_STRUCT(WGPUSharedTextureMemoryAHardwareBufferDescriptor, { \ @@ -2596,7 +2689,6 @@ typedef struct WGPUSharedTextureMemoryAHardwareBufferDescriptor { /*.sType=*/WGPUSType_SharedTextureMemoryAHardwareBufferDescriptor _wgpu_COMMA \ }) _wgpu_COMMA \ /*.handle=*/NULL _wgpu_COMMA \ - /*.useExternalFormat=*/WGPU_FALSE _wgpu_COMMA \ }) // Can be chained in WGPUSharedTextureMemoryBeginAccessDescriptor @@ -3142,15 +3234,15 @@ typedef struct WGPUTextureBindingLayout { }) // Can be chained in WGPUTextureDescriptor -typedef struct WGPUTextureBindingViewDimensionDescriptor { +typedef struct WGPUTextureBindingViewDimension { WGPUChainedStruct chain; WGPUTextureViewDimension textureBindingViewDimension; -} WGPUTextureBindingViewDimensionDescriptor WGPU_STRUCTURE_ATTRIBUTE; +} WGPUTextureBindingViewDimension WGPU_STRUCTURE_ATTRIBUTE; -#define WGPU_TEXTURE_BINDING_VIEW_DIMENSION_DESCRIPTOR_INIT _wgpu_MAKE_INIT_STRUCT(WGPUTextureBindingViewDimensionDescriptor, { \ +#define WGPU_TEXTURE_BINDING_VIEW_DIMENSION_INIT _wgpu_MAKE_INIT_STRUCT(WGPUTextureBindingViewDimension, { \ /*.chain=*/_wgpu_MAKE_INIT_STRUCT(WGPUChainedStruct, { \ /*.next=*/NULL _wgpu_COMMA \ - /*.sType=*/WGPUSType_TextureBindingViewDimensionDescriptor _wgpu_COMMA \ + /*.sType=*/WGPUSType_TextureBindingViewDimension _wgpu_COMMA \ }) _wgpu_COMMA \ /*.textureBindingViewDimension=*/WGPUTextureViewDimension_Undefined _wgpu_COMMA \ }) @@ -3612,6 +3704,22 @@ typedef struct WGPURenderPassColorAttachment { /*.clearValue=*/WGPU_COLOR_INIT _wgpu_COMMA \ }) +// Can be chained in WGPURenderPassDescriptor +typedef struct WGPURenderPassRenderAreaRect { + WGPUChainedStruct chain; + WGPUOrigin2D origin; + WGPUExtent2D size; +} WGPURenderPassRenderAreaRect WGPU_STRUCTURE_ATTRIBUTE; + +#define WGPU_RENDER_PASS_RENDER_AREA_RECT_INIT _wgpu_MAKE_INIT_STRUCT(WGPURenderPassRenderAreaRect, { \ + /*.chain=*/_wgpu_MAKE_INIT_STRUCT(WGPUChainedStruct, { \ + /*.next=*/NULL _wgpu_COMMA \ + /*.sType=*/WGPUSType_RenderPassRenderAreaRect _wgpu_COMMA \ + }) _wgpu_COMMA \ + /*.origin=*/WGPU_ORIGIN_2D_INIT _wgpu_COMMA \ + /*.size=*/WGPU_EXTENT_2D_INIT _wgpu_COMMA \ +}) + typedef struct WGPURenderPassStorageAttachment { WGPUChainedStruct * nextInChain; uint64_t offset; @@ -3688,6 +3796,16 @@ typedef struct WGPUShaderModuleDescriptor { /*.label=*/WGPU_STRING_VIEW_INIT _wgpu_COMMA \ }) +typedef struct WGPUSharedBufferMemoryDescriptor { + WGPUChainedStruct * nextInChain; + WGPUStringView label; +} WGPUSharedBufferMemoryDescriptor WGPU_STRUCTURE_ATTRIBUTE; + +#define WGPU_SHARED_BUFFER_MEMORY_DESCRIPTOR_INIT _wgpu_MAKE_INIT_STRUCT(WGPUSharedBufferMemoryDescriptor, { \ + /*.nextInChain=*/NULL _wgpu_COMMA \ + /*.label=*/WGPU_STRING_VIEW_INIT _wgpu_COMMA \ +}) + typedef struct WGPUSharedFenceDescriptor { WGPUChainedStruct * nextInChain; WGPUStringView label; @@ -3728,6 +3846,7 @@ typedef struct WGPUSharedTextureMemoryBeginAccessDescriptor { WGPUBool initialized; size_t fenceCount; WGPUSharedFence const * fences; + size_t signaledValueCount; uint64_t const * signaledValues; } WGPUSharedTextureMemoryBeginAccessDescriptor WGPU_STRUCTURE_ATTRIBUTE; @@ -3737,6 +3856,7 @@ typedef struct WGPUSharedTextureMemoryBeginAccessDescriptor { /*.initialized=*/WGPU_FALSE _wgpu_COMMA \ /*.fenceCount=*/0 _wgpu_COMMA \ /*.fences=*/NULL _wgpu_COMMA \ + /*.signaledValueCount=*/0 _wgpu_COMMA \ /*.signaledValues=*/NULL _wgpu_COMMA \ }) @@ -4043,6 +4163,7 @@ typedef struct WGPUSharedTextureMemoryEndAccessState { WGPUBool initialized; size_t fenceCount; WGPUSharedFence const * fences; + size_t signaledValueCount; uint64_t const * signaledValues; } WGPUSharedTextureMemoryEndAccessState WGPU_STRUCTURE_ATTRIBUTE; @@ -4051,6 +4172,7 @@ typedef struct WGPUSharedTextureMemoryEndAccessState { /*.initialized=*/WGPU_FALSE _wgpu_COMMA \ /*.fenceCount=*/0 _wgpu_COMMA \ /*.fences=*/NULL _wgpu_COMMA \ + /*.signaledValueCount=*/0 _wgpu_COMMA \ /*.signaledValues=*/NULL _wgpu_COMMA \ }) @@ -4440,6 +4562,7 @@ typedef void (*WGPUProcResourceTableDestroy)(WGPUResourceTable resourceTable) WG typedef uint32_t (*WGPUProcResourceTableGetSize)(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE; typedef uint32_t (*WGPUProcResourceTableInsertBinding)(WGPUResourceTable resourceTable, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE; typedef WGPUStatus (*WGPUProcResourceTableRemoveBinding)(WGPUResourceTable resourceTable, uint32_t slot) WGPU_FUNCTION_ATTRIBUTE; +typedef void (*WGPUProcResourceTableSetLabel)(WGPUResourceTable resourceTable, WGPUStringView label) WGPU_FUNCTION_ATTRIBUTE; typedef WGPUStatus (*WGPUProcResourceTableUpdate)(WGPUResourceTable resourceTable, uint32_t slot, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE; typedef void (*WGPUProcResourceTableAddRef)(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE; typedef void (*WGPUProcResourceTableRelease)(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE; @@ -4470,6 +4593,7 @@ typedef void (*WGPUProcSharedBufferMemoryEndAccessStateFreeMembers)(WGPUSharedBu // Procs of SharedFence typedef void (*WGPUProcSharedFenceExportInfo)(WGPUSharedFence sharedFence, WGPUSharedFenceExportInfo * info) WGPU_FUNCTION_ATTRIBUTE; +typedef void (*WGPUProcSharedFenceSetLabel)(WGPUSharedFence sharedFence, WGPUStringView label) WGPU_FUNCTION_ATTRIBUTE; typedef void (*WGPUProcSharedFenceAddRef)(WGPUSharedFence sharedFence) WGPU_FUNCTION_ATTRIBUTE; typedef void (*WGPUProcSharedFenceRelease)(WGPUSharedFence sharedFence) WGPU_FUNCTION_ATTRIBUTE; @@ -4795,6 +4919,7 @@ WGPU_EXPORT void wgpuResourceTableDestroy(WGPUResourceTable resourceTable) WGPU_ WGPU_EXPORT uint32_t wgpuResourceTableGetSize(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT uint32_t wgpuResourceTableInsertBinding(WGPUResourceTable resourceTable, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT WGPUStatus wgpuResourceTableRemoveBinding(WGPUResourceTable resourceTable, uint32_t slot) WGPU_FUNCTION_ATTRIBUTE; +WGPU_EXPORT void wgpuResourceTableSetLabel(WGPUResourceTable resourceTable, WGPUStringView label) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT WGPUStatus wgpuResourceTableUpdate(WGPUResourceTable resourceTable, uint32_t slot, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT void wgpuResourceTableAddRef(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT void wgpuResourceTableRelease(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE; @@ -4825,6 +4950,7 @@ WGPU_EXPORT void wgpuSharedBufferMemoryEndAccessStateFreeMembers(WGPUSharedBuffe // Methods of SharedFence WGPU_EXPORT void wgpuSharedFenceExportInfo(WGPUSharedFence sharedFence, WGPUSharedFenceExportInfo * info) WGPU_FUNCTION_ATTRIBUTE; +WGPU_EXPORT void wgpuSharedFenceSetLabel(WGPUSharedFence sharedFence, WGPUStringView label) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT void wgpuSharedFenceAddRef(WGPUSharedFence sharedFence) WGPU_FUNCTION_ATTRIBUTE; WGPU_EXPORT void wgpuSharedFenceRelease(WGPUSharedFence sharedFence) WGPU_FUNCTION_ATTRIBUTE; diff --git a/3rdparty/dawn/src/tint/api/common/binding_point.h b/3rdparty/dawn/src/tint/api/common/binding_point.h index f6110d4f0..3993e72d5 100644 --- a/3rdparty/dawn/src/tint/api/common/binding_point.h +++ b/3rdparty/dawn/src/tint/api/common/binding_point.h @@ -33,16 +33,18 @@ #include #include "src/tint/utils/math/hash.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/rtti/traits.h" namespace tint { /// BindingPoint holds a group and binding index. struct BindingPoint { - /// The `@group` part of the binding point + /// The index for the bind group. + /// In WGSL, this is `@group`, but in backends it may have been remapped to something else. uint32_t group = 0; - /// The `@binding` part of the binding point + /// The index for the bind point within the bind group. + /// In WGSL, this is `@binding`, but in backends it may have been remapped to something else. uint32_t binding = 0; /// Reflect the fields of this class so that it can be used by tint::ForeachField() diff --git a/3rdparty/dawn/src/tint/api/common/bindings.h b/3rdparty/dawn/src/tint/api/common/bindings.h index 8972170ff..faacaa801 100644 --- a/3rdparty/dawn/src/tint/api/common/bindings.h +++ b/3rdparty/dawn/src/tint/api/common/bindings.h @@ -31,12 +31,12 @@ #include #include "src/tint/api/common/binding_point.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { -/// An external texture -struct ExternalTexture { +/// A multiplanar external texture +struct ExternalMultiplanarTexture { /// Metadata BindingPoint metadata{}; /// Plane0 binding data @@ -45,14 +45,30 @@ struct ExternalTexture { BindingPoint plane1{}; /// Reflect the fields of this class so that it can be used by tint::ForeachField() - TINT_REFLECT(ExternalTexture, metadata, plane0, plane1); + TINT_REFLECT(ExternalMultiplanarTexture, metadata, plane0, plane1); + TINT_REFLECT_HASH_CODE(ExternalMultiplanarTexture); + bool operator==(const ExternalMultiplanarTexture&) const = default; +}; - TINT_REFLECT_EQUALS(ExternalTexture); - TINT_REFLECT_HASH_CODE(ExternalTexture); +/// A YCBcr external texture +struct ExternalYCBCRTexture { + /// Metadata + BindingPoint metadata{}; + /// texture binding data + BindingPoint texture{}; + /// sampler binding data + BindingPoint sampler{}; + + /// Reflect the fields of this class so that it can be used by tint::ForeachField() + TINT_REFLECT(ExternalYCBCRTexture, metadata, texture, sampler); + TINT_REFLECT_HASH_CODE(ExternalYCBCRTexture); + bool operator==(const ExternalYCBCRTexture&) const = default; }; using BindingMap = std::unordered_map; -using ExternalTextureBindings = std::unordered_map; +using ExternalTextureBindings = + std::unordered_map>; /// Binding information struct Bindings { @@ -64,6 +80,8 @@ struct Bindings { BindingMap texture{}; /// Storage texture bindings BindingMap storage_texture{}; + /// Texel buffer bindings + BindingMap texel_buffer{}; /// Sampler bindings BindingMap sampler{}; /// External bindings @@ -77,12 +95,14 @@ struct Bindings { storage, texture, storage_texture, + texel_buffer, sampler, external_texture, input_attachment); - TINT_REFLECT_EQUALS(Bindings); TINT_REFLECT_HASH_CODE(Bindings); + + bool operator==(const Bindings&) const = default; }; } // namespace tint diff --git a/3rdparty/dawn/src/tint/api/common/override_id.h b/3rdparty/dawn/src/tint/api/common/override_id.h index 3f97a99c5..c12309382 100644 --- a/3rdparty/dawn/src/tint/api/common/override_id.h +++ b/3rdparty/dawn/src/tint/api/common/override_id.h @@ -33,7 +33,7 @@ #include #include "src/tint/utils/math/hash.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { diff --git a/3rdparty/dawn/src/tint/api/common/resource_table_config.h b/3rdparty/dawn/src/tint/api/common/resource_table_config.h index e47ae4951..bfdaaff18 100644 --- a/3rdparty/dawn/src/tint/api/common/resource_table_config.h +++ b/3rdparty/dawn/src/tint/api/common/resource_table_config.h @@ -33,7 +33,7 @@ #include "src/tint/api/common/binding_point.h" #include "src/tint/api/common/resource_type.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { @@ -88,11 +88,23 @@ struct ResourceTableConfig { // std::vector default_binding_type_order; + // If true, the sampler index is stored in the metadata table alongside the type id: sampler + // index in the high 16 bits, type id in the low 16 bits. This is used on backends that limit + // the number of bound shader samplers. + bool get_sampler_index_from_metadata = false; + + // Map from a post-remap binding-point to the ResourceType which is bound to that binding point. + // The table must contain entries for any bind-ful entry which is used with a bindless resource. + // (In practise, adding all bind-ful texture and sampler entries is sufficient) + std::unordered_map binding_to_resource_type; + TINT_REFLECT(ResourceTableConfig, resource_table_binding, storage_buffer_binding, - default_binding_type_order); - TINT_REFLECT_EQUALS(ResourceTableConfig); + default_binding_type_order, + get_sampler_index_from_metadata, + binding_to_resource_type); + bool operator==(const ResourceTableConfig&) const = default; }; } // namespace tint diff --git a/3rdparty/dawn/src/tint/api/common/resource_type.h b/3rdparty/dawn/src/tint/api/common/resource_type.h index 9527d11d2..e42e0bc73 100644 --- a/3rdparty/dawn/src/tint/api/common/resource_type.h +++ b/3rdparty/dawn/src/tint/api/common/resource_type.h @@ -28,53 +28,74 @@ #ifndef SRC_TINT_API_COMMON_RESOURCE_TYPE_H_ #define SRC_TINT_API_COMMON_RESOURCE_TYPE_H_ -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { enum class ResourceType : uint32_t { - kEmpty, + kEmpty = 0, - kTexture1d_f32_filterable, - kTexture1d_f32_unfilterable, - kTexture1d_i32, - kTexture1d_u32, - kTexture2d_f32_filterable, - kTexture2d_f32_unfilterable, - kTexture2d_i32, - kTexture2d_u32, - kTexture2dArray_f32_filterable, - kTexture2dArray_f32_unfilterable, - kTexture2dArray_i32, - kTexture2dArray_u32, - kTexture3d_f32_filterable, - kTexture3d_f32_unfilterable, - kTexture3d_i32, - kTexture3d_u32, - kTextureCube_f32_filterable, - kTextureCube_f32_unfilterable, - kTextureCube_i32, - kTextureCube_u32, - kTextureCubeArray_f32_filterable, - kTextureCubeArray_f32_unfilterable, - kTextureCubeArray_i32, - kTextureCubeArray_u32, + kTexture1d_f32_filterable = 1, + kTexture1d_f32_unfilterable = 2, + kTexture1d_f32_unknown_filterable = 3, + kTexture1d_i32 = 4, + kTexture1d_u32 = 5, + kTexture2d_f32_filterable = 6, + kTexture2d_f32_unfilterable = 7, + kTexture2d_f32_unknown_filterable = 8, + kTexture2d_i32 = 9, + kTexture2d_u32 = 10, + kTexture2dArray_f32_filterable = 11, + kTexture2dArray_f32_unfilterable = 12, + kTexture2dArray_f32_unknown_filterable = 13, + kTexture2dArray_i32 = 14, + kTexture2dArray_u32 = 15, + kTexture3d_f32_filterable = 16, + kTexture3d_f32_unfilterable = 17, + kTexture3d_f32_unknown_filterable = 18, + kTexture3d_i32 = 19, + kTexture3d_u32 = 20, + kTextureCube_f32_filterable = 21, + kTextureCube_f32_unfilterable = 22, + kTextureCube_f32_unknown_filterable = 23, + kTextureCube_i32 = 24, + kTextureCube_u32 = 25, + kTextureCubeArray_f32_filterable = 26, + kTextureCubeArray_f32_unfilterable = 27, + kTextureCubeArray_f32_unknown_filterable = 28, + kTextureCubeArray_i32 = 29, + kTextureCubeArray_u32 = 30, - kTextureMultisampled2d_f32, - kTextureMultisampled2d_i32, - kTextureMultisampled2d_u32, + kTextureMultisampled2d_f32 = 31, + kTextureMultisampled2d_i32 = 32, + kTextureMultisampled2d_u32 = 33, - kTextureDepth2d, - kTextureDepth2dArray, - kTextureDepthCube, - kTextureDepthCubeArray, - kTextureDepthMultisampled2d, + kTextureDepth2d = 34, + kTextureDepth2dArray = 35, + kTextureDepthCube = 36, + kTextureDepthCubeArray = 37, + kTextureDepthMultisampled2d = 38, - kSampler_filtering, - kSampler_non_filtering, - kSampler_comparison, + kSampler = 39, + kSampler_filtering = 40, + kSampler_non_filtering = 41, + kSampler_comparison = 42, }; -TINT_REFLECT_ENUM_RANGE(tint::ResourceType, kEmpty, kTextureDepthMultisampled2d); +TINT_REFLECT_ENUM_RANGE(tint::ResourceType, kEmpty, kSampler_comparison); + +constexpr bool IsSampler(ResourceType res_type) { + switch (res_type) { + case ResourceType::kSampler: + case ResourceType::kSampler_filtering: + case ResourceType::kSampler_non_filtering: + case ResourceType::kSampler_comparison: + return true; + + default: + break; + } + return false; +} } // namespace tint diff --git a/3rdparty/dawn/src/tint/api/common/subgroup_matrix.h b/3rdparty/dawn/src/tint/api/common/subgroup_matrix.h index 2c9249e46..6f9398764 100644 --- a/3rdparty/dawn/src/tint/api/common/subgroup_matrix.h +++ b/3rdparty/dawn/src/tint/api/common/subgroup_matrix.h @@ -31,7 +31,7 @@ #include #include "src/tint/utils/math/hash.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { @@ -46,16 +46,17 @@ enum class SubgroupMatrixType : uint8_t { TINT_REFLECT_ENUM_RANGE(tint::SubgroupMatrixType, kF16, kI32); struct SubgroupMatrixMultiply { - uint32_t M; - uint32_t N; - uint32_t K; + uint32_t M = 0; + uint32_t N = 0; + uint32_t K = 0; - SubgroupMatrixType input_type; - SubgroupMatrixType output_type; + SubgroupMatrixType input_type = SubgroupMatrixType::kF32; + SubgroupMatrixType output_type = SubgroupMatrixType::kF32; TINT_REFLECT(SubgroupMatrixMultiply, M, N, K, input_type, output_type); - TINT_REFLECT_EQUALS(SubgroupMatrixMultiply); TINT_REFLECT_HASH_CODE(SubgroupMatrixMultiply); + + bool operator==(const SubgroupMatrixMultiply&) const = default; }; enum class SubgroupMatrixDirection : uint8_t { @@ -66,16 +67,17 @@ enum class SubgroupMatrixDirection : uint8_t { TINT_REFLECT_ENUM_RANGE(tint::SubgroupMatrixDirection, kLeft, kResult); struct SubgroupMatrixConfig { - uint32_t M; - uint32_t N; - uint32_t K; + uint32_t M = 0; + uint32_t N = 0; + uint32_t K = 0; - SubgroupMatrixType type; + SubgroupMatrixType type = SubgroupMatrixType::kF32; SubgroupMatrixDirection direction; TINT_REFLECT(SubgroupMatrixConfig, M, N, K, type, direction); - TINT_REFLECT_EQUALS(SubgroupMatrixConfig); TINT_REFLECT_HASH_CODE(SubgroupMatrixConfig); + + bool operator==(const SubgroupMatrixConfig&) const = default; }; } // namespace tint @@ -103,8 +105,9 @@ struct SubgroupMatrixInfo { std::unordered_set configs; TINT_REFLECT(SubgroupMatrixInfo, multiplies, configs); - TINT_REFLECT_EQUALS(SubgroupMatrixInfo); TINT_REFLECT_HASH_CODE(SubgroupMatrixInfo); + + bool operator==(const SubgroupMatrixInfo&) const = default; }; } // namespace tint diff --git a/3rdparty/dawn/src/tint/api/common/substitute_overrides_config.h b/3rdparty/dawn/src/tint/api/common/substitute_overrides_config.h index 78db68944..90d0e1393 100644 --- a/3rdparty/dawn/src/tint/api/common/substitute_overrides_config.h +++ b/3rdparty/dawn/src/tint/api/common/substitute_overrides_config.h @@ -31,7 +31,7 @@ #include #include "src/tint/api/common/override_id.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { @@ -44,8 +44,9 @@ struct SubstituteOverridesConfig { /// Reflect the fields of this class so that it can be used by tint::ForeachField() TINT_REFLECT(SubstituteOverridesConfig, map); - TINT_REFLECT_EQUALS(SubstituteOverridesConfig); TINT_REFLECT_HASH_CODE(SubstituteOverridesConfig); + + bool operator==(const SubstituteOverridesConfig&) const = default; }; } // namespace tint diff --git a/3rdparty/dawn/src/tint/api/common/vertex_pulling_config.h b/3rdparty/dawn/src/tint/api/common/vertex_pulling_config.h index 58ca1a117..418975aa0 100644 --- a/3rdparty/dawn/src/tint/api/common/vertex_pulling_config.h +++ b/3rdparty/dawn/src/tint/api/common/vertex_pulling_config.h @@ -31,7 +31,7 @@ #include #include -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint { @@ -80,22 +80,174 @@ enum class VertexFormat : uint8_t { kUnorm8x4BGRA, // unorm8x4-bgra }; +/// @param out the stream to write to +/// @param format the vertex format +/// @returns @p out so calls can be chained +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, VertexFormat format) { + switch (format) { + case VertexFormat::kUint8: + out << "uint8"; + break; + case VertexFormat::kUint8x2: + out << "uint8x2"; + break; + case VertexFormat::kUint8x4: + out << "uint8x4"; + break; + case VertexFormat::kSint8: + out << "sint8"; + break; + case VertexFormat::kSint8x2: + out << "sint8x2"; + break; + case VertexFormat::kSint8x4: + out << "sint8x4"; + break; + case VertexFormat::kUnorm8: + out << "unorm8"; + break; + case VertexFormat::kUnorm8x2: + out << "unorm8x2"; + break; + case VertexFormat::kUnorm8x4: + out << "unorm8x4"; + break; + case VertexFormat::kSnorm8: + out << "snorm8"; + break; + case VertexFormat::kSnorm8x2: + out << "snorm8x2"; + break; + case VertexFormat::kSnorm8x4: + out << "snorm8x4"; + break; + case VertexFormat::kUint16: + out << "uint16"; + break; + case VertexFormat::kUint16x2: + out << "uint16x2"; + break; + case VertexFormat::kUint16x4: + out << "uint16x4"; + break; + case VertexFormat::kSint16: + out << "sint16"; + break; + case VertexFormat::kSint16x2: + out << "sint16x2"; + break; + case VertexFormat::kSint16x4: + out << "sint16x4"; + break; + case VertexFormat::kUnorm16: + out << "unorm16"; + break; + case VertexFormat::kUnorm16x2: + out << "unorm16x2"; + break; + case VertexFormat::kUnorm16x4: + out << "unorm16x4"; + break; + case VertexFormat::kSnorm16: + out << "snorm16"; + break; + case VertexFormat::kSnorm16x2: + out << "snorm16x2"; + break; + case VertexFormat::kSnorm16x4: + out << "snorm16x4"; + break; + case VertexFormat::kFloat16: + out << "float16"; + break; + case VertexFormat::kFloat16x2: + out << "float16x2"; + break; + case VertexFormat::kFloat16x4: + out << "float16x4"; + break; + case VertexFormat::kFloat32: + out << "float32"; + break; + case VertexFormat::kFloat32x2: + out << "float32x2"; + break; + case VertexFormat::kFloat32x3: + out << "float32x3"; + break; + case VertexFormat::kFloat32x4: + out << "float32x4"; + break; + case VertexFormat::kUint32: + out << "uint32"; + break; + case VertexFormat::kUint32x2: + out << "uint32x2"; + break; + case VertexFormat::kUint32x3: + out << "uint32x3"; + break; + case VertexFormat::kUint32x4: + out << "uint32x4"; + break; + case VertexFormat::kSint32: + out << "sint32"; + break; + case VertexFormat::kSint32x2: + out << "sint32x2"; + break; + case VertexFormat::kSint32x3: + out << "sint32x3"; + break; + case VertexFormat::kSint32x4: + out << "sint32x4"; + break; + case VertexFormat::kUnorm10_10_10_2: + out << "unorm10_10_10_2"; + break; + case VertexFormat::kUnorm8x4BGRA: + out << "unorm8x4BGRA"; + break; + } + return out; +} + /// Describes if a vertex attribute increments with vertex index or instance index. enum class VertexStepMode : uint8_t { kVertex, kInstance }; +/// @param out the stream to write to +/// @param mode the step mode +/// @returns @p out so calls can be chained +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, VertexStepMode mode) { + switch (mode) { + case VertexStepMode::kVertex: + out << "vertex"; + break; + case VertexStepMode::kInstance: + out << "instance"; + break; + } + return out; +} + /// Describes a vertex attribute within a buffer struct VertexAttributeDescriptor { /// The format of the attribute. - VertexFormat format; + VertexFormat format = VertexFormat::kUint8; /// The byte offset of the attribute in the buffer. - uint32_t offset; + uint32_t offset = 0; /// The shader location used for the attribute. - uint32_t shader_location; + uint32_t shader_location = 0; /// Reflect the fields of this class so that it can be used by tint::ForeachField() TINT_REFLECT(VertexAttributeDescriptor, format, offset, shader_location); - TINT_REFLECT_EQUALS(VertexAttributeDescriptor); TINT_REFLECT_HASH_CODE(VertexAttributeDescriptor); + + bool operator==(const VertexAttributeDescriptor&) const = default; }; /// Describes a buffer containing multiple vertex attributes @@ -118,8 +270,9 @@ struct VertexBufferLayoutDescriptor { /// Reflect the fields of this class so that it can be used by tint::ForeachField() TINT_REFLECT(VertexBufferLayoutDescriptor, array_stride, step_mode, attributes); - TINT_REFLECT_EQUALS(VertexBufferLayoutDescriptor); TINT_REFLECT_HASH_CODE(VertexBufferLayoutDescriptor); + + bool operator==(const VertexBufferLayoutDescriptor&) const = default; }; /// Configuration options that control the vertex pulling transform. @@ -133,12 +286,13 @@ struct VertexPullingConfig { /// Reflect the fields of this class so that it can be used by tint::ForeachField() TINT_REFLECT(VertexPullingConfig, vertex_state, pulling_group); - TINT_REFLECT_EQUALS(VertexPullingConfig); TINT_REFLECT_HASH_CODE(VertexPullingConfig); + + bool operator==(const VertexPullingConfig&) const = default; }; /// Reflection for VertexFormat. -TINT_REFLECT_ENUM_RANGE(tint::VertexFormat, kUint8x2, kUnorm8x4BGRA); +TINT_REFLECT_ENUM_RANGE(tint::VertexFormat, kUint8, kUnorm8x4BGRA); /// Reflection for VertexStepMode. TINT_REFLECT_ENUM_RANGE(tint::VertexStepMode, kVertex, kInstance); diff --git a/3rdparty/dawn/src/tint/api/common/workgroup_info.h b/3rdparty/dawn/src/tint/api/common/workgroup_info.h index 962cde854..d670f2081 100644 --- a/3rdparty/dawn/src/tint/api/common/workgroup_info.h +++ b/3rdparty/dawn/src/tint/api/common/workgroup_info.h @@ -44,7 +44,7 @@ struct WorkgroupInfo { uint32_t z = 0; /// The needed workgroup storage size - size_t storage_size = 0; + uint64_t storage_size = 0; /// The `@subgroup_size` attribute std::optional subgroup_size; diff --git a/3rdparty/dawn/src/tint/api/helpers/generate_bindings.cc b/3rdparty/dawn/src/tint/api/helpers/generate_bindings.cc index 937daed17..299ed44a1 100644 --- a/3rdparty/dawn/src/tint/api/helpers/generate_bindings.cc +++ b/3rdparty/dawn/src/tint/api/helpers/generate_bindings.cc @@ -28,7 +28,6 @@ #include "src/tint/api/helpers/generate_bindings.h" #include -#include #include "src/tint/api/common/binding_point.h" #include "src/tint/lang/core/ir/module.h" @@ -37,6 +36,7 @@ #include "src/tint/lang/core/type/external_texture.h" #include "src/tint/lang/core/type/pointer.h" #include "src/tint/lang/core/type/storage_texture.h" +#include "src/tint/lang/core/type/texel_buffer.h" #include "src/tint/utils/rtti/switch.h" namespace tint { @@ -44,7 +44,8 @@ namespace tint { Bindings GenerateBindings(const core::ir::Module& module, const std::string& ep, bool set_group_to_zero, - bool flatten_bindings) { + bool flatten_bindings, + std::unordered_set ycbcr_bindings) { Bindings bindings{}; uint32_t next_buffer_idx = 0; @@ -111,6 +112,13 @@ Bindings GenerateBindings(const core::ir::Module& module, }; bindings.storage_texture.emplace(*bp, info); }, + [&](const core::type::TexelBuffer*) { + tint::BindingPoint info{ + .group = set_group_to_zero ? 0 : bp->group, + .binding = flatten_bindings ? next_texture_idx++ : bp->binding, + }; + bindings.texel_buffer.emplace(*bp, info); + }, [&](const core::type::Texture*) { tint::BindingPoint info{ .group = set_group_to_zero ? 0 : bp->group, @@ -152,9 +160,17 @@ Bindings GenerateBindings(const core::ir::Module& module, uint32_t g = set_group_to_zero ? 0 : bp.group; tint::BindingPoint plane0{.group = g, .binding = next_texture_idx++}; - tint::BindingPoint plane1{.group = g, .binding = next_texture_idx++}; tint::BindingPoint metadata{.group = g, .binding = next_buffer_idx++}; - bindings.external_texture.emplace(bp, ExternalTexture{metadata, plane0, plane1}); + + if (ycbcr_bindings.contains(bp)) { + tint::BindingPoint sampler{.group = g, .binding = next_sampler_idx++}; + bindings.external_texture.emplace(bp, + ExternalYCBCRTexture{metadata, plane0, sampler}); + } else { + tint::BindingPoint plane1{.group = g, .binding = next_texture_idx++}; + bindings.external_texture.emplace( + bp, ExternalMultiplanarTexture{metadata, plane0, plane1}); + } } } else { for (auto bp : ext_tex_bps) { @@ -164,7 +180,14 @@ Bindings GenerateBindings(const core::ir::Module& module, tint::BindingPoint plane0{.group = g, .binding = bp.binding}; tint::BindingPoint plane1{.group = g, .binding = next_num++}; tint::BindingPoint metadata{.group = g, .binding = next_num++}; - bindings.external_texture.emplace(bp, ExternalTexture{metadata, plane0, plane1}); + + if (ycbcr_bindings.contains(bp)) { + bindings.external_texture.emplace(bp, + ExternalYCBCRTexture{metadata, plane0, plane1}); + } else { + bindings.external_texture.emplace( + bp, ExternalMultiplanarTexture{metadata, plane0, plane1}); + } } } diff --git a/3rdparty/dawn/src/tint/api/helpers/generate_bindings.h b/3rdparty/dawn/src/tint/api/helpers/generate_bindings.h index 987852202..dcaf00111 100644 --- a/3rdparty/dawn/src/tint/api/helpers/generate_bindings.h +++ b/3rdparty/dawn/src/tint/api/helpers/generate_bindings.h @@ -29,6 +29,7 @@ #define SRC_TINT_API_HELPERS_GENERATE_BINDINGS_H_ #include +#include #include "src/tint/api/common/bindings.h" @@ -43,11 +44,13 @@ namespace tint { /// @param module the module to generate from /// @param set_group_to_zero if true, the group used for bindings will always be zero /// @param flatten_bindings if true, the bindings will remap to count from 0 +/// @param ycbcr_bindings flags a binding as YCBCR data. /// @returns the bindings Bindings GenerateBindings(const core::ir::Module& module, const std::string& ep, bool set_group_to_zero, - bool flatten_bindings); + bool flatten_bindings, + std::unordered_set ycbcr_bindings = {}); } // namespace tint diff --git a/3rdparty/dawn/src/tint/lang/core/constant/eval.cc b/3rdparty/dawn/src/tint/lang/core/constant/eval.cc index d948b84ab..335c295c5 100644 --- a/3rdparty/dawn/src/tint/lang/core/constant/eval.cc +++ b/3rdparty/dawn/src/tint/lang/core/constant/eval.cc @@ -70,6 +70,14 @@ T First(T&& first, ...) { return std::forward(first); } +/// Helper that calls `f` passing in the value of all `cs`. +/// Calls `f` with all constants cast to the type of the first `cs` argument. +template +auto Dispatch_u32(F&& f, CONSTANTS&&... cs) { + return Switch(First(cs...)->Type(), // + [&](const core::type::U32*) { return f(cs->template ValueAs()...); }); +} + /// Helper that calls `f` passing in the value of all `cs`. /// Calls `f` with all constants cast to the type of the first `cs` argument. template @@ -473,12 +481,13 @@ const Value* ConvertInternal(const Value* root_value, /// If `f`'s last argument is a `size_t`, then the index of the most deeply nested element inside /// the most deeply nested aggregate type will be passed in. template -std::enable_if_t>, Eval::Result> -TransformElements(Manager& mgr, - const core::type::Type* composite_ty, - const F& f, - size_t index, - CONSTANTS&&... cs) { +Eval::Result TransformElements(Manager& mgr, + const core::type::Type* composite_ty, + const F& f, + size_t index, + CONSTANTS&&... cs) + requires(tint::traits::IsType>) +{ auto [el_ty, n] = First(cs...)->Type()->Elements(); if (!el_ty) { return f(cs..., index); @@ -1836,13 +1845,17 @@ Eval::Result Eval::ShiftLeft(const core::type::Type* ty, e2u = 0; } } else { - if (static_cast(e2) >= bit_width && use_runtime_semantics_) { + if (static_cast(e2) >= bit_width) { // At shader/pipeline-creation time, it is an error to shift by the bit width of - // the lhs or greater, which should have already been caught by the validator. + // the lhs or greater. The WGSL frontend validator should have already caught + // this for constant expressions, but not for overrides. // At runtime, we shift by e2 % (bit width of e1). AddError(source) << "shift left value must be less than the bit width of the lhs, which is " << bit_width; + if (!use_runtime_semantics_) { + return Failure(); + } e2u = e2u % bit_width; } @@ -1923,13 +1936,17 @@ Eval::Result Eval::ShiftRight(const core::type::Type* ty, result = signed_shift_right(); } } else { - if (static_cast(e2) >= bit_width && use_runtime_semantics_) { + if (static_cast(e2) >= bit_width) { // At shader/pipeline-creation time, it is an error to shift by the bit width of - // the lhs or greater, which should have already been caught by the validator. + // the lhs or greater. The WGSL frontend validator should have already caught + // this for constant expressions, but not for overrides. // At runtime, we shift by e2 % (bit width of e1). AddError(source) << "shift right value must be less than the bit width of the lhs, which is " << bit_width; + if (!use_runtime_semantics_) { + return Failure(); + } e2u = e2u % bit_width; } @@ -1950,6 +1967,23 @@ Eval::Result Eval::ShiftRight(const core::type::Type* ty, return TransformBinaryElements(mgr, ty, transform, args[0], args[1]); } +Eval::Result Eval::addSat(const core::type::Type* ty, + VectorRef args, + const Source& source) { + auto transform = [&](const Value* lhs, const Value* rhs) { + auto create = [&](auto a, auto b) { + using NumberT = decltype(a); + NumberT result = NumberT{a + b}; + if (result < NumberT{a}) { + result = NumberT::Highest(); + } + return CreateScalar(source, ty->DeepestElement(), result); + }; + return Dispatch_u32(create, lhs, rhs); + }; + return TransformBinaryElements(mgr, ty, transform, args[0], args[1]); +} + Eval::Result Eval::abs(const core::type::Type* ty, VectorRef args, const Source& source) { diff --git a/3rdparty/dawn/src/tint/lang/core/constant/eval.h b/3rdparty/dawn/src/tint/lang/core/constant/eval.h index 17c5786c8..251a79a3b 100644 --- a/3rdparty/dawn/src/tint/lang/core/constant/eval.h +++ b/3rdparty/dawn/src/tint/lang/core/constant/eval.h @@ -367,6 +367,13 @@ class Eval { // Builtins //////////////////////////////////////////////////////////////////////////// + /// addSat builtin + /// @param ty the expression type + /// @param args the input arguments + /// @param source the source location + /// @return the result value, or null if the value cannot be calculated + Result addSat(const core::type::Type* ty, VectorRef args, const Source& source); + /// abs builtin /// @param ty the expression type /// @param args the input arguments diff --git a/3rdparty/dawn/src/tint/lang/core/enums.cc b/3rdparty/dawn/src/tint/lang/core/enums.cc index 682a60de0..ce4f0c632 100644 --- a/3rdparty/dawn/src/tint/lang/core/enums.cc +++ b/3rdparty/dawn/src/tint/lang/core/enums.cc @@ -192,50 +192,26 @@ std::string_view ToString(InterpolationType value) { return ""; } -/// ParseSamplerFiltering parses a SamplerFiltering from a string. +/// ParseMajorness parses a Majorness from a string. /// @param str the string to parse -/// @returns the parsed enum, or SamplerFiltering::kUndefined if the string could not be parsed. -SamplerFiltering ParseSamplerFiltering(std::string_view str) { - if (str == "filtering") { - return SamplerFiltering::kFiltering; +/// @returns the parsed enum, or Majorness::kUndefined if the string could not be parsed. +Majorness ParseMajorness(std::string_view str) { + if (str == "col_major") { + return Majorness::kColMajor; } - if (str == "non_filtering") { - return SamplerFiltering::kNonFiltering; + if (str == "row_major") { + return Majorness::kRowMajor; } - return SamplerFiltering::kUndefined; + return Majorness::kUndefined; } -std::string_view ToString(SamplerFiltering value) { +std::string_view ToString(Majorness value) { switch (value) { - case SamplerFiltering::kUndefined: + case Majorness::kUndefined: return "undefined"; - case SamplerFiltering::kFiltering: - return "filtering"; - case SamplerFiltering::kNonFiltering: - return "non_filtering"; - } - return ""; -} - -/// ParseTextureFilterable parses a TextureFilterable from a string. -/// @param str the string to parse -/// @returns the parsed enum, or TextureFilterable::kUndefined if the string could not be parsed. -TextureFilterable ParseTextureFilterable(std::string_view str) { - if (str == "filterable") { - return TextureFilterable::kFilterable; - } - if (str == "unfilterable") { - return TextureFilterable::kUnfilterable; - } - return TextureFilterable::kUndefined; -} -std::string_view ToString(TextureFilterable value) { - switch (value) { - case TextureFilterable::kUndefined: - return "undefined"; - case TextureFilterable::kFilterable: - return "filterable"; - case TextureFilterable::kUnfilterable: - return "unfilterable"; + case Majorness::kColMajor: + return "col_major"; + case Majorness::kRowMajor: + return "row_major"; } return ""; } @@ -1149,9 +1125,6 @@ std::string_view ToString(BuiltinValue value) { /// @param str the string to parse /// @returns the parsed enum, or BuiltinDepthMode::kUndefined if the string could not be parsed. BuiltinDepthMode ParseBuiltinDepthMode(std::string_view str) { - if (str == "any") { - return BuiltinDepthMode::kAny; - } if (str == "greater") { return BuiltinDepthMode::kGreater; } @@ -1164,8 +1137,6 @@ std::string_view ToString(BuiltinDepthMode value) { switch (value) { case BuiltinDepthMode::kUndefined: return "undefined"; - case BuiltinDepthMode::kAny: - return "any"; case BuiltinDepthMode::kGreater: return "greater"; case BuiltinDepthMode::kLess: @@ -1445,6 +1416,9 @@ BuiltinFn ParseBuiltinFn(std::string_view name) { if (name == "atanh") { return BuiltinFn::kAtanh; } + if (name == "bitcast") { + return BuiltinFn::kBitcast; + } if (name == "ceil") { return BuiltinFn::kCeil; } @@ -1682,6 +1656,9 @@ BuiltinFn ParseBuiltinFn(std::string_view name) { if (name == "unpack4xU8") { return BuiltinFn::kUnpack4XU8; } + if (name == "addSat") { + return BuiltinFn::kAddSat; + } if (name == "storageBarrier") { return BuiltinFn::kStorageBarrier; } @@ -1877,6 +1854,9 @@ BuiltinFn ParseBuiltinFn(std::string_view name) { if (name == "bufferView") { return BuiltinFn::kBufferView; } + if (name == "bufferArrayView") { + return BuiltinFn::kBufferArrayView; + } if (name == "bufferLength") { return BuiltinFn::kBufferLength; } @@ -1918,6 +1898,8 @@ const char* str(BuiltinFn i) { return "atan2"; case BuiltinFn::kAtanh: return "atanh"; + case BuiltinFn::kBitcast: + return "bitcast"; case BuiltinFn::kCeil: return "ceil"; case BuiltinFn::kClamp: @@ -2076,6 +2058,8 @@ const char* str(BuiltinFn i) { return "unpack4xI8"; case BuiltinFn::kUnpack4XU8: return "unpack4xU8"; + case BuiltinFn::kAddSat: + return "addSat"; case BuiltinFn::kStorageBarrier: return "storageBarrier"; case BuiltinFn::kWorkgroupBarrier: @@ -2206,6 +2190,8 @@ const char* str(BuiltinFn i) { return "subgroupMatrixScalarMultiply"; case BuiltinFn::kBufferView: return "bufferView"; + case BuiltinFn::kBufferArrayView: + return "bufferArrayView"; case BuiltinFn::kBufferLength: return "bufferLength"; case BuiltinFn::kPrint: diff --git a/3rdparty/dawn/src/tint/lang/core/enums.h b/3rdparty/dawn/src/tint/lang/core/enums.h index a36ea2641..55bde75c1 100644 --- a/3rdparty/dawn/src/tint/lang/core/enums.h +++ b/3rdparty/dawn/src/tint/lang/core/enums.h @@ -41,7 +41,7 @@ #include -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/rtti/traits.h" namespace tint::core { @@ -198,67 +198,37 @@ constexpr std::string_view kInterpolationTypeStrings[] = { "perspective", }; -/// The sampler filtering. -enum class SamplerFiltering : uint8_t { +/// The majorness of a matrix. +enum class Majorness : uint8_t { kUndefined, - kFiltering, - kNonFiltering, + kColMajor, + kRowMajor, }; /// @param value the enum value /// @returns the string for the given enum value -std::string_view ToString(SamplerFiltering value); +std::string_view ToString(Majorness value); /// @param out the stream to write to -/// @param value the SamplerFiltering +/// @param value the Majorness /// @returns @p out so calls can be chained template requires(traits::IsOStream) -auto& operator<<(STREAM& out, SamplerFiltering value) { +auto& operator<<(STREAM& out, Majorness value) { return out << ToString(value); } -/// ParseSamplerFiltering parses a SamplerFiltering from a string. +/// ParseMajorness parses a Majorness from a string. /// @param str the string to parse -/// @returns the parsed enum, or SamplerFiltering::kUndefined if the string could not be parsed. -SamplerFiltering ParseSamplerFiltering(std::string_view str); +/// @returns the parsed enum, or Majorness::kUndefined if the string could not be parsed. +Majorness ParseMajorness(std::string_view str); -constexpr std::string_view kSamplerFilteringStrings[] = { - "filtering", - "non_filtering", +constexpr std::string_view kMajornessStrings[] = { + "col_major", + "row_major", }; -/// The texture filterable. -enum class TextureFilterable : uint8_t { - kUndefined, - kFilterable, - kUnfilterable, -}; - -/// @param value the enum value -/// @returns the string for the given enum value -std::string_view ToString(TextureFilterable value); - -/// @param out the stream to write to -/// @param value the TextureFilterable -/// @returns @p out so calls can be chained -template - requires(traits::IsOStream) -auto& operator<<(STREAM& out, TextureFilterable value) { - return out << ToString(value); -} - -/// ParseTextureFilterable parses a TextureFilterable from a string. -/// @param str the string to parse -/// @returns the parsed enum, or TextureFilterable::kUndefined if the string could not be parsed. -TextureFilterable ParseTextureFilterable(std::string_view str); - -constexpr std::string_view kTextureFilterableStrings[] = { - "filterable", - "unfilterable", -}; - -/// Address space of a given pointer. +/// The kind of subgroup matrix. enum class SubgroupMatrixKind : uint8_t { kUndefined, kLeft, @@ -705,7 +675,6 @@ constexpr std::string_view kBuiltinValueStrings[] = { /// Builtin depth mode defined with `@builtin(, )`. enum class BuiltinDepthMode : uint8_t { kUndefined, - kAny, kGreater, kLess, }; @@ -729,7 +698,6 @@ auto& operator<<(STREAM& out, BuiltinDepthMode value) { BuiltinDepthMode ParseBuiltinDepthMode(std::string_view str); constexpr std::string_view kBuiltinDepthModeStrings[] = { - "any", "greater", "less", }; @@ -890,6 +858,7 @@ enum class BuiltinFn : uint8_t { kAtan, kAtan2, kAtanh, + kBitcast, kCeil, kClamp, kCos, @@ -969,6 +938,7 @@ enum class BuiltinFn : uint8_t { kUnpack4X8Unorm, kUnpack4XI8, kUnpack4XU8, + kAddSat, kStorageBarrier, kWorkgroupBarrier, kTextureBarrier, @@ -1034,6 +1004,7 @@ enum class BuiltinFn : uint8_t { kSubgroupMatrixScalarSubtract, kSubgroupMatrixScalarMultiply, kBufferView, + kBufferArrayView, kBufferLength, kPrint, kHasResource, @@ -1072,6 +1043,7 @@ constexpr BuiltinFn kBuiltinFns[] = { BuiltinFn::kAtan, BuiltinFn::kAtan2, BuiltinFn::kAtanh, + BuiltinFn::kBitcast, BuiltinFn::kCeil, BuiltinFn::kClamp, BuiltinFn::kCos, @@ -1151,6 +1123,7 @@ constexpr BuiltinFn kBuiltinFns[] = { BuiltinFn::kUnpack4X8Unorm, BuiltinFn::kUnpack4XI8, BuiltinFn::kUnpack4XU8, + BuiltinFn::kAddSat, BuiltinFn::kStorageBarrier, BuiltinFn::kWorkgroupBarrier, BuiltinFn::kTextureBarrier, @@ -1216,6 +1189,7 @@ constexpr BuiltinFn kBuiltinFns[] = { BuiltinFn::kSubgroupMatrixScalarSubtract, BuiltinFn::kSubgroupMatrixScalarMultiply, BuiltinFn::kBufferView, + BuiltinFn::kBufferArrayView, BuiltinFn::kBufferLength, BuiltinFn::kPrint, BuiltinFn::kHasResource, @@ -1235,6 +1209,7 @@ constexpr const char* kBuiltinFnStrings[] = { "atan", "atan2", "atanh", + "bitcast", "ceil", "clamp", "cos", @@ -1314,6 +1289,7 @@ constexpr const char* kBuiltinFnStrings[] = { "unpack4x8unorm", "unpack4xI8", "unpack4xU8", + "addSat", "storageBarrier", "workgroupBarrier", "textureBarrier", @@ -1379,6 +1355,7 @@ constexpr const char* kBuiltinFnStrings[] = { "subgroupMatrixScalarSubtract", "subgroupMatrixScalarMultiply", "bufferView", + "bufferArrayView", "bufferLength", "print", "hasResource", diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.cc b/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.cc index 6d7975a1a..fb48c7195 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.cc +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.cc @@ -84,6 +84,10 @@ const char* str(CtorConv i) { return "subgroup_matrix_right"; case CtorConv::kSubgroup_matrix_result: return "subgroup_matrix_result"; + case CtorConv::kU16: + return "u16"; + case CtorConv::kU64: + return "u64"; } return ""; } diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.h b/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.h index 2416dd6d1..bf9096f01 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.h +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/ctor_conv.h @@ -68,6 +68,8 @@ enum class CtorConv : uint8_t { kSubgroup_matrix_left, kSubgroup_matrix_right, kSubgroup_matrix_result, + kU16, + kU64, kNone, }; diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/data.cc b/3rdparty/dawn/src/tint/lang/core/intrinsic/data.cc index 6a9279318..9fddaf520 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/data.cc +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/data.cc @@ -634,26 +634,6 @@ constexpr TypeMatcher kSamplerComparisonMatcher { }; -/// TypeMatcher for 'type sampler_filtered' -constexpr TypeMatcher kSamplerFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - Number F = Number::invalid; - if (!MatchSamplerFiltered(state, ty, F)) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildSamplerFiltered(state, ty, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F; - state->PrintNum(F); - out << style::Type("sampler<", F, ">"); - } -}; - - /// TypeMatcher for 'type texture_1d' constexpr TypeMatcher kTexture1DMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -774,162 +754,6 @@ constexpr TypeMatcher kTextureCubeArrayMatcher { }; -/// TypeMatcher for 'type texture_1d_filtered' -constexpr TypeMatcher kTexture1DFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture1DFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture1DFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_1d"); - } -}; - - -/// TypeMatcher for 'type texture_2d_filtered' -constexpr TypeMatcher kTexture2DFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture2DFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture2DFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_2d"); - } -}; - - -/// TypeMatcher for 'type texture_2d_array_filtered' -constexpr TypeMatcher kTexture2DArrayFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture2DArrayFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture2DArrayFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_2d_array"); - } -}; - - -/// TypeMatcher for 'type texture_3d_filtered' -constexpr TypeMatcher kTexture3DFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture3DFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture3DFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_3d"); - } -}; - - -/// TypeMatcher for 'type texture_cube_filtered' -constexpr TypeMatcher kTextureCubeFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTextureCubeFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTextureCubeFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_cube"); - } -}; - - -/// TypeMatcher for 'type texture_cube_array_filtered' -constexpr TypeMatcher kTextureCubeArrayFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTextureCubeArrayFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTextureCubeArrayFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_cube_array"); - } -}; - - /// TypeMatcher for 'type texture_multisampled_2d' constexpr TypeMatcher kTextureMultisampled2DMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -1426,12 +1250,15 @@ constexpr TypeMatcher kScalarNoF32Matcher { if (MatchBool(state, ty)) { return BuildBool(state, ty); } + if (MatchU16(state, ty)) { + return BuildU16(state, ty); + } return nullptr; }, /* print */ [](MatchState*, StyledText& out) { // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. - kI32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} + kI32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kBoolMatcher.print(nullptr, out); out << style::Plain(" or "); kU16Matcher.print(nullptr, out);} }; /// TypeMatcher for 'match scalar_no_f16' @@ -1449,12 +1276,15 @@ constexpr TypeMatcher kScalarNoF16Matcher { if (MatchBool(state, ty)) { return BuildBool(state, ty); } + if (MatchU16(state, ty)) { + return BuildU16(state, ty); + } return nullptr; }, /* print */ [](MatchState*, StyledText& out) { // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. - kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} + kF32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kBoolMatcher.print(nullptr, out); out << style::Plain(" or "); kU16Matcher.print(nullptr, out);} }; /// TypeMatcher for 'match scalar_no_i32' @@ -1472,12 +1302,15 @@ constexpr TypeMatcher kScalarNoI32Matcher { if (MatchBool(state, ty)) { return BuildBool(state, ty); } + if (MatchU16(state, ty)) { + return BuildU16(state, ty); + } return nullptr; }, /* print */ [](MatchState*, StyledText& out) { // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. - kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} + kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kBoolMatcher.print(nullptr, out); out << style::Plain(" or "); kU16Matcher.print(nullptr, out);} }; /// TypeMatcher for 'match scalar_no_u32' @@ -1495,12 +1328,15 @@ constexpr TypeMatcher kScalarNoU32Matcher { if (MatchBool(state, ty)) { return BuildBool(state, ty); } + if (MatchU16(state, ty)) { + return BuildU16(state, ty); + } return nullptr; }, /* print */ [](MatchState*, StyledText& out) { // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. - kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} + kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kBoolMatcher.print(nullptr, out); out << style::Plain(" or "); kU16Matcher.print(nullptr, out);} }; /// TypeMatcher for 'match scalar_no_bool' @@ -1526,6 +1362,32 @@ constexpr TypeMatcher kScalarNoBoolMatcher { kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(" or "); kU32Matcher.print(nullptr, out);} }; +/// TypeMatcher for 'match scalar_no_u16' +constexpr TypeMatcher kScalarNoU16Matcher { +/* match */ [](MatchState& state, const Type* ty) -> const Type* { + if (MatchI32(state, ty)) { + return BuildI32(state, ty); + } + if (MatchU32(state, ty)) { + return BuildU32(state, ty); + } + if (MatchF32(state, ty)) { + return BuildF32(state, ty); + } + if (MatchF16(state, ty)) { + return BuildF16(state, ty); + } + if (MatchBool(state, ty)) { + return BuildBool(state, ty); + } + return nullptr; + }, +/* print */ [](MatchState*, StyledText& out) { + // Note: We pass nullptr to the Matcher.print() functions, as matchers do not support + // template arguments, nor can they match sub-types. As such, they have no use for the MatchState. + kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(" or "); kBoolMatcher.print(nullptr, out);} +}; + /// TypeMatcher for 'match fiu32_f16' constexpr TypeMatcher kFiu32F16Matcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -1709,90 +1571,6 @@ constexpr TypeMatcher kSubgroupMatrixElementsMatcher { kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU8Matcher.print(nullptr, out); out << style::Plain(" or "); kI8Matcher.print(nullptr, out);} }; -/// EnumMatcher for 'match filterable' -constexpr NumberMatcher kFilterableMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::TextureFilterable::kFilterable)) { - return Number(static_cast(core::TextureFilterable::kFilterable)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filterable"); - } -}; - -/// EnumMatcher for 'match unfilterable' -constexpr NumberMatcher kUnfilterableMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::TextureFilterable::kUnfilterable)) { - return Number(static_cast(core::TextureFilterable::kUnfilterable)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("unfilterable"); - } -}; - -/// EnumMatcher for 'match filtering' -constexpr NumberMatcher kFilteringMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::SamplerFiltering::kFiltering)) { - return Number(static_cast(core::SamplerFiltering::kFiltering)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filtering"); - } -}; - -/// EnumMatcher for 'match non_filtering' -constexpr NumberMatcher kNonFilteringMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::SamplerFiltering::kNonFiltering)) { - return Number(static_cast(core::SamplerFiltering::kNonFiltering)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("non_filtering"); - } -}; - -/// EnumMatcher for 'match texture_filter' -constexpr NumberMatcher kTextureFilterMatcher { -/* match */ [](MatchState&, Number number) -> Number { - switch (static_cast(number.Value())) { - case core::TextureFilterable::kFilterable: - case core::TextureFilterable::kUnfilterable: - return number; - default: - return Number::invalid; - } - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filterable")<< style::Plain(" or ") << style::Enum("unfilterable"); - } -}; - -/// EnumMatcher for 'match sampler_filter' -constexpr NumberMatcher kSamplerFilterMatcher { -/* match */ [](MatchState&, Number number) -> Number { - switch (static_cast(number.Value())) { - case core::SamplerFiltering::kFiltering: - case core::SamplerFiltering::kNonFiltering: - return number; - default: - return Number::invalid; - } - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filtering")<< style::Plain(" or ") << style::Enum("non_filtering"); - } -}; - /// EnumMatcher for 'match subgroup_matrix_kind_left' constexpr NumberMatcher kSubgroupMatrixKindLeftMatcher { /* match */ [](MatchState&, Number number) -> Number { @@ -2060,6 +1838,23 @@ constexpr NumberMatcher kWorkgroupMatcher { } }; +/// EnumMatcher for 'match workgroup_uniform_storage' +constexpr NumberMatcher kWorkgroupUniformStorageMatcher { +/* match */ [](MatchState&, Number number) -> Number { + switch (static_cast(number.Value())) { + case core::AddressSpace::kWorkgroup: + case core::AddressSpace::kUniform: + case core::AddressSpace::kStorage: + return number; + default: + return Number::invalid; + } + }, +/* print */ [](MatchState*, StyledText& out) { + out<< style::Enum("workgroup")<< style::Plain(", ") << style::Enum("uniform")<< style::Plain(" or ") << style::Enum("storage"); + } +}; + /// Type and number matchers /// The template types, types, and type matchers @@ -2070,85 +1865,82 @@ constexpr TypeMatcher kTypeMatchers[] = { /* [3] */ TemplateTypeMatcher<3>::matcher, /* [4] */ TemplateTypeMatcher<4>::matcher, /* [5] */ TemplateTypeMatcher<5>::matcher, - /* [6] */ kBoolMatcher, - /* [7] */ kI8Matcher, - /* [8] */ kU8Matcher, - /* [9] */ kU16Matcher, - /* [10] */ kI32Matcher, - /* [11] */ kU32Matcher, - /* [12] */ kF32Matcher, - /* [13] */ kF16Matcher, - /* [14] */ kVec2Matcher, - /* [15] */ kVec3Matcher, - /* [16] */ kVec4Matcher, - /* [17] */ kMat2X2Matcher, - /* [18] */ kMat2X3Matcher, - /* [19] */ kMat2X4Matcher, - /* [20] */ kMat3X2Matcher, - /* [21] */ kMat3X3Matcher, - /* [22] */ kMat3X4Matcher, - /* [23] */ kMat4X2Matcher, - /* [24] */ kMat4X3Matcher, - /* [25] */ kMat4X4Matcher, - /* [26] */ kVecMatcher, - /* [27] */ kMatMatcher, - /* [28] */ kPtrMatcher, - /* [29] */ kAtomicMatcher, - /* [30] */ kRuntimeArrayMatcher, - /* [31] */ kArrayMatcher, - /* [32] */ kBindingArrayMatcher, - /* [33] */ kSamplerMatcher, - /* [34] */ kSamplerComparisonMatcher, - /* [35] */ kSamplerFilteredMatcher, - /* [36] */ kTexture1DMatcher, - /* [37] */ kTexture2DMatcher, - /* [38] */ kTexture2DArrayMatcher, - /* [39] */ kTexture3DMatcher, - /* [40] */ kTextureCubeMatcher, - /* [41] */ kTextureCubeArrayMatcher, - /* [42] */ kTexture1DFilteredMatcher, - /* [43] */ kTexture2DFilteredMatcher, - /* [44] */ kTexture2DArrayFilteredMatcher, - /* [45] */ kTexture3DFilteredMatcher, - /* [46] */ kTextureCubeFilteredMatcher, - /* [47] */ kTextureCubeArrayFilteredMatcher, - /* [48] */ kTextureMultisampled2DMatcher, - /* [49] */ kTextureDepth2DMatcher, - /* [50] */ kTextureDepth2DArrayMatcher, - /* [51] */ kTextureDepthCubeMatcher, - /* [52] */ kTextureDepthCubeArrayMatcher, - /* [53] */ kTextureDepthMultisampled2DMatcher, - /* [54] */ kTextureStorage1DMatcher, - /* [55] */ kTextureStorage2DMatcher, - /* [56] */ kTextureStorage2DArrayMatcher, - /* [57] */ kTextureStorage3DMatcher, - /* [58] */ kTextureExternalMatcher, - /* [59] */ kTexelBufferMatcher, - /* [60] */ kInputAttachmentMatcher, - /* [61] */ kModfResultMatcher, - /* [62] */ kModfResultVecMatcher, - /* [63] */ kFrexpResultMatcher, - /* [64] */ kFrexpResultVecMatcher, - /* [65] */ kAtomicCompareExchangeResultMatcher, - /* [66] */ kSubgroupMatrixMatcher, - /* [67] */ kUnsizedBufferMatcher, - /* [68] */ kBufferMatcher, - /* [69] */ kU64Matcher, - /* [70] */ kScalarMatcher, - /* [71] */ kScalarNoF32Matcher, - /* [72] */ kScalarNoF16Matcher, - /* [73] */ kScalarNoI32Matcher, - /* [74] */ kScalarNoU32Matcher, - /* [75] */ kScalarNoBoolMatcher, - /* [76] */ kFiu32F16Matcher, - /* [77] */ kFiu32Matcher, - /* [78] */ kFi32F16Matcher, - /* [79] */ kFi32Matcher, - /* [80] */ kF32F16Matcher, - /* [81] */ kIu32Matcher, - /* [82] */ kIu32Iu8Matcher, - /* [83] */ kIu8Matcher, - /* [84] */ kSubgroupMatrixElementsMatcher, + /* [6] */ TemplateTypeMatcher<6>::matcher, + /* [7] */ TemplateTypeMatcher<7>::matcher, + /* [8] */ TemplateTypeMatcher<8>::matcher, + /* [9] */ kBoolMatcher, + /* [10] */ kI8Matcher, + /* [11] */ kU8Matcher, + /* [12] */ kU16Matcher, + /* [13] */ kI32Matcher, + /* [14] */ kU32Matcher, + /* [15] */ kF32Matcher, + /* [16] */ kF16Matcher, + /* [17] */ kVec2Matcher, + /* [18] */ kVec3Matcher, + /* [19] */ kVec4Matcher, + /* [20] */ kMat2X2Matcher, + /* [21] */ kMat2X3Matcher, + /* [22] */ kMat2X4Matcher, + /* [23] */ kMat3X2Matcher, + /* [24] */ kMat3X3Matcher, + /* [25] */ kMat3X4Matcher, + /* [26] */ kMat4X2Matcher, + /* [27] */ kMat4X3Matcher, + /* [28] */ kMat4X4Matcher, + /* [29] */ kVecMatcher, + /* [30] */ kMatMatcher, + /* [31] */ kPtrMatcher, + /* [32] */ kAtomicMatcher, + /* [33] */ kRuntimeArrayMatcher, + /* [34] */ kArrayMatcher, + /* [35] */ kBindingArrayMatcher, + /* [36] */ kSamplerMatcher, + /* [37] */ kSamplerComparisonMatcher, + /* [38] */ kTexture1DMatcher, + /* [39] */ kTexture2DMatcher, + /* [40] */ kTexture2DArrayMatcher, + /* [41] */ kTexture3DMatcher, + /* [42] */ kTextureCubeMatcher, + /* [43] */ kTextureCubeArrayMatcher, + /* [44] */ kTextureMultisampled2DMatcher, + /* [45] */ kTextureDepth2DMatcher, + /* [46] */ kTextureDepth2DArrayMatcher, + /* [47] */ kTextureDepthCubeMatcher, + /* [48] */ kTextureDepthCubeArrayMatcher, + /* [49] */ kTextureDepthMultisampled2DMatcher, + /* [50] */ kTextureStorage1DMatcher, + /* [51] */ kTextureStorage2DMatcher, + /* [52] */ kTextureStorage2DArrayMatcher, + /* [53] */ kTextureStorage3DMatcher, + /* [54] */ kTextureExternalMatcher, + /* [55] */ kTexelBufferMatcher, + /* [56] */ kInputAttachmentMatcher, + /* [57] */ kModfResultMatcher, + /* [58] */ kModfResultVecMatcher, + /* [59] */ kFrexpResultMatcher, + /* [60] */ kFrexpResultVecMatcher, + /* [61] */ kAtomicCompareExchangeResultMatcher, + /* [62] */ kSubgroupMatrixMatcher, + /* [63] */ kUnsizedBufferMatcher, + /* [64] */ kBufferMatcher, + /* [65] */ kU64Matcher, + /* [66] */ kScalarMatcher, + /* [67] */ kScalarNoF32Matcher, + /* [68] */ kScalarNoF16Matcher, + /* [69] */ kScalarNoI32Matcher, + /* [70] */ kScalarNoU32Matcher, + /* [71] */ kScalarNoBoolMatcher, + /* [72] */ kScalarNoU16Matcher, + /* [73] */ kFiu32F16Matcher, + /* [74] */ kFiu32Matcher, + /* [75] */ kFi32F16Matcher, + /* [76] */ kFi32Matcher, + /* [77] */ kF32F16Matcher, + /* [78] */ kIu32Matcher, + /* [79] */ kIu32Iu8Matcher, + /* [80] */ kIu8Matcher, + /* [81] */ kSubgroupMatrixElementsMatcher, }; /// The template numbers, and number matchers @@ -2159,562 +1951,505 @@ constexpr NumberMatcher kNumberMatchers[] = { /* [3] */ TemplateNumberMatcher<3>::matcher, /* [4] */ TemplateNumberMatcher<4>::matcher, /* [5] */ TemplateNumberMatcher<5>::matcher, - /* [6] */ kFilterableMatcher, - /* [7] */ kUnfilterableMatcher, - /* [8] */ kFilteringMatcher, - /* [9] */ kNonFilteringMatcher, - /* [10] */ kTextureFilterMatcher, - /* [11] */ kSamplerFilterMatcher, - /* [12] */ kSubgroupMatrixKindLeftMatcher, - /* [13] */ kSubgroupMatrixKindRightMatcher, - /* [14] */ kSubgroupMatrixKindResultMatcher, - /* [15] */ kF32TexelFormatMatcher, - /* [16] */ kI32TexelFormatMatcher, - /* [17] */ kU32TexelFormatMatcher, - /* [18] */ kReadMatcher, - /* [19] */ kWriteMatcher, - /* [20] */ kReadWriteMatcher, - /* [21] */ kReadableMatcher, - /* [22] */ kWritableMatcher, - /* [23] */ kFunctionPrivateWorkgroupMatcher, - /* [24] */ kWorkgroupOrStorageMatcher, - /* [25] */ kUniformOrStorageMatcher, - /* [26] */ kStorageMatcher, - /* [27] */ kWorkgroupMatcher, + /* [6] */ TemplateNumberMatcher<6>::matcher, + /* [7] */ TemplateNumberMatcher<7>::matcher, + /* [8] */ TemplateNumberMatcher<8>::matcher, + /* [9] */ kSubgroupMatrixKindLeftMatcher, + /* [10] */ kSubgroupMatrixKindRightMatcher, + /* [11] */ kSubgroupMatrixKindResultMatcher, + /* [12] */ kF32TexelFormatMatcher, + /* [13] */ kI32TexelFormatMatcher, + /* [14] */ kU32TexelFormatMatcher, + /* [15] */ kReadMatcher, + /* [16] */ kWriteMatcher, + /* [17] */ kReadWriteMatcher, + /* [18] */ kReadableMatcher, + /* [19] */ kWritableMatcher, + /* [20] */ kFunctionPrivateWorkgroupMatcher, + /* [21] */ kWorkgroupOrStorageMatcher, + /* [22] */ kUniformOrStorageMatcher, + /* [23] */ kStorageMatcher, + /* [24] */ kWorkgroupMatcher, + /* [25] */ kWorkgroupUniformStorageMatcher, }; constexpr MatcherIndex kMatcherIndices[] = { - /* [0] */ MatcherIndex(28), - /* [1] */ MatcherIndex(24), - /* [2] */ MatcherIndex(31), + /* [0] */ MatcherIndex(31), + /* [1] */ MatcherIndex(6), + /* [2] */ MatcherIndex(34), /* [3] */ MatcherIndex(2), /* [4] */ MatcherIndex(5), - /* [5] */ MatcherIndex(21), - /* [6] */ MatcherIndex(0), - /* [7] */ MatcherIndex(28), - /* [8] */ MatcherIndex(24), - /* [9] */ MatcherIndex(31), - /* [10] */ MatcherIndex(10), - /* [11] */ MatcherIndex(5), - /* [12] */ MatcherIndex(21), - /* [13] */ MatcherIndex(12), - /* [14] */ MatcherIndex(28), - /* [15] */ MatcherIndex(24), - /* [16] */ MatcherIndex(31), - /* [17] */ MatcherIndex(11), - /* [18] */ MatcherIndex(5), - /* [19] */ MatcherIndex(21), - /* [20] */ MatcherIndex(13), - /* [21] */ MatcherIndex(28), - /* [22] */ MatcherIndex(24), - /* [23] */ MatcherIndex(31), - /* [24] */ MatcherIndex(1), - /* [25] */ MatcherIndex(4), - /* [26] */ MatcherIndex(22), - /* [27] */ MatcherIndex(0), - /* [28] */ MatcherIndex(28), - /* [29] */ MatcherIndex(24), + /* [5] */ MatcherIndex(7), + /* [6] */ MatcherIndex(31), + /* [7] */ MatcherIndex(6), + /* [8] */ MatcherIndex(34), + /* [9] */ MatcherIndex(13), + /* [10] */ MatcherIndex(5), + /* [11] */ MatcherIndex(7), + /* [12] */ MatcherIndex(31), + /* [13] */ MatcherIndex(6), + /* [14] */ MatcherIndex(34), + /* [15] */ MatcherIndex(14), + /* [16] */ MatcherIndex(5), + /* [17] */ MatcherIndex(7), + /* [18] */ MatcherIndex(31), + /* [19] */ MatcherIndex(7), + /* [20] */ MatcherIndex(34), + /* [21] */ MatcherIndex(3), + /* [22] */ MatcherIndex(6), + /* [23] */ MatcherIndex(8), + /* [24] */ MatcherIndex(31), + /* [25] */ MatcherIndex(7), + /* [26] */ MatcherIndex(34), + /* [27] */ MatcherIndex(13), + /* [28] */ MatcherIndex(6), + /* [29] */ MatcherIndex(8), /* [30] */ MatcherIndex(31), - /* [31] */ MatcherIndex(10), - /* [32] */ MatcherIndex(4), - /* [33] */ MatcherIndex(22), - /* [34] */ MatcherIndex(12), - /* [35] */ MatcherIndex(28), - /* [36] */ MatcherIndex(24), - /* [37] */ MatcherIndex(31), - /* [38] */ MatcherIndex(11), - /* [39] */ MatcherIndex(4), - /* [40] */ MatcherIndex(22), - /* [41] */ MatcherIndex(13), - /* [42] */ MatcherIndex(28), - /* [43] */ MatcherIndex(26), - /* [44] */ MatcherIndex(30), - /* [45] */ MatcherIndex(0), - /* [46] */ MatcherIndex(1), - /* [47] */ MatcherIndex(28), - /* [48] */ MatcherIndex(1), - /* [49] */ MatcherIndex(29), - /* [50] */ MatcherIndex(0), - /* [51] */ MatcherIndex(20), - /* [52] */ MatcherIndex(0), - /* [53] */ MatcherIndex(28), - /* [54] */ MatcherIndex(26), - /* [55] */ MatcherIndex(29), - /* [56] */ MatcherIndex(69), - /* [57] */ MatcherIndex(20), - /* [58] */ MatcherIndex(12), - /* [59] */ MatcherIndex(66), + /* [31] */ MatcherIndex(7), + /* [32] */ MatcherIndex(34), + /* [33] */ MatcherIndex(14), + /* [34] */ MatcherIndex(6), + /* [35] */ MatcherIndex(8), + /* [36] */ MatcherIndex(31), + /* [37] */ MatcherIndex(5), + /* [38] */ MatcherIndex(34), + /* [39] */ MatcherIndex(1), + /* [40] */ MatcherIndex(4), + /* [41] */ MatcherIndex(6), + /* [42] */ MatcherIndex(31), + /* [43] */ MatcherIndex(5), + /* [44] */ MatcherIndex(34), + /* [45] */ MatcherIndex(13), + /* [46] */ MatcherIndex(4), + /* [47] */ MatcherIndex(6), + /* [48] */ MatcherIndex(31), + /* [49] */ MatcherIndex(5), + /* [50] */ MatcherIndex(34), + /* [51] */ MatcherIndex(14), + /* [52] */ MatcherIndex(4), + /* [53] */ MatcherIndex(6), + /* [54] */ MatcherIndex(31), + /* [55] */ MatcherIndex(1), + /* [56] */ MatcherIndex(33), + /* [57] */ MatcherIndex(0), + /* [58] */ MatcherIndex(2), + /* [59] */ MatcherIndex(31), /* [60] */ MatcherIndex(1), - /* [61] */ MatcherIndex(2), - /* [62] */ MatcherIndex(3), - /* [63] */ MatcherIndex(4), - /* [64] */ MatcherIndex(28), - /* [65] */ MatcherIndex(26), - /* [66] */ MatcherIndex(30), - /* [67] */ MatcherIndex(2), - /* [68] */ MatcherIndex(21), - /* [69] */ MatcherIndex(28), - /* [70] */ MatcherIndex(26), - /* [71] */ MatcherIndex(30), - /* [72] */ MatcherIndex(10), - /* [73] */ MatcherIndex(21), - /* [74] */ MatcherIndex(28), - /* [75] */ MatcherIndex(26), - /* [76] */ MatcherIndex(30), - /* [77] */ MatcherIndex(11), - /* [78] */ MatcherIndex(21), - /* [79] */ MatcherIndex(28), - /* [80] */ MatcherIndex(26), - /* [81] */ MatcherIndex(30), - /* [82] */ MatcherIndex(1), - /* [83] */ MatcherIndex(22), - /* [84] */ MatcherIndex(66), - /* [85] */ MatcherIndex(0), - /* [86] */ MatcherIndex(1), - /* [87] */ MatcherIndex(2), - /* [88] */ MatcherIndex(3), - /* [89] */ MatcherIndex(28), - /* [90] */ MatcherIndex(26), - /* [91] */ MatcherIndex(30), - /* [92] */ MatcherIndex(10), - /* [93] */ MatcherIndex(22), - /* [94] */ MatcherIndex(28), - /* [95] */ MatcherIndex(26), - /* [96] */ MatcherIndex(30), - /* [97] */ MatcherIndex(11), - /* [98] */ MatcherIndex(22), - /* [99] */ MatcherIndex(66), - /* [100] */ MatcherIndex(14), - /* [101] */ MatcherIndex(0), - /* [102] */ MatcherIndex(2), - /* [103] */ MatcherIndex(3), - /* [104] */ MatcherIndex(66), - /* [105] */ MatcherIndex(12), - /* [106] */ MatcherIndex(1), - /* [107] */ MatcherIndex(4), - /* [108] */ MatcherIndex(3), - /* [109] */ MatcherIndex(66), - /* [110] */ MatcherIndex(13), - /* [111] */ MatcherIndex(1), - /* [112] */ MatcherIndex(2), - /* [113] */ MatcherIndex(4), - /* [114] */ MatcherIndex(66), - /* [115] */ MatcherIndex(14), - /* [116] */ MatcherIndex(1), - /* [117] */ MatcherIndex(2), - /* [118] */ MatcherIndex(3), - /* [119] */ MatcherIndex(66), - /* [120] */ MatcherIndex(12), - /* [121] */ MatcherIndex(0), - /* [122] */ MatcherIndex(4), - /* [123] */ MatcherIndex(3), - /* [124] */ MatcherIndex(66), - /* [125] */ MatcherIndex(13), - /* [126] */ MatcherIndex(0), - /* [127] */ MatcherIndex(2), - /* [128] */ MatcherIndex(4), - /* [129] */ MatcherIndex(66), - /* [130] */ MatcherIndex(0), - /* [131] */ MatcherIndex(7), - /* [132] */ MatcherIndex(1), - /* [133] */ MatcherIndex(2), - /* [134] */ MatcherIndex(66), - /* [135] */ MatcherIndex(0), - /* [136] */ MatcherIndex(8), - /* [137] */ MatcherIndex(1), - /* [138] */ MatcherIndex(2), - /* [139] */ MatcherIndex(28), - /* [140] */ MatcherIndex(2), - /* [141] */ MatcherIndex(68), - /* [142] */ MatcherIndex(4), + /* [61] */ MatcherIndex(32), + /* [62] */ MatcherIndex(0), + /* [63] */ MatcherIndex(17), + /* [64] */ MatcherIndex(16), + /* [65] */ MatcherIndex(31), + /* [66] */ MatcherIndex(23), + /* [67] */ MatcherIndex(32), + /* [68] */ MatcherIndex(65), + /* [69] */ MatcherIndex(17), + /* [70] */ MatcherIndex(74), + /* [71] */ MatcherIndex(62), + /* [72] */ MatcherIndex(1), + /* [73] */ MatcherIndex(2), + /* [74] */ MatcherIndex(3), + /* [75] */ MatcherIndex(4), + /* [76] */ MatcherIndex(31), + /* [77] */ MatcherIndex(23), + /* [78] */ MatcherIndex(33), + /* [79] */ MatcherIndex(2), + /* [80] */ MatcherIndex(5), + /* [81] */ MatcherIndex(31), + /* [82] */ MatcherIndex(23), + /* [83] */ MatcherIndex(33), + /* [84] */ MatcherIndex(13), + /* [85] */ MatcherIndex(5), + /* [86] */ MatcherIndex(31), + /* [87] */ MatcherIndex(23), + /* [88] */ MatcherIndex(33), + /* [89] */ MatcherIndex(14), + /* [90] */ MatcherIndex(5), + /* [91] */ MatcherIndex(62), + /* [92] */ MatcherIndex(2), + /* [93] */ MatcherIndex(3), + /* [94] */ MatcherIndex(4), + /* [95] */ MatcherIndex(5), + /* [96] */ MatcherIndex(31), + /* [97] */ MatcherIndex(23), + /* [98] */ MatcherIndex(33), + /* [99] */ MatcherIndex(3), + /* [100] */ MatcherIndex(6), + /* [101] */ MatcherIndex(31), + /* [102] */ MatcherIndex(23), + /* [103] */ MatcherIndex(33), + /* [104] */ MatcherIndex(13), + /* [105] */ MatcherIndex(6), + /* [106] */ MatcherIndex(31), + /* [107] */ MatcherIndex(23), + /* [108] */ MatcherIndex(33), + /* [109] */ MatcherIndex(14), + /* [110] */ MatcherIndex(6), + /* [111] */ MatcherIndex(31), + /* [112] */ MatcherIndex(23), + /* [113] */ MatcherIndex(33), + /* [114] */ MatcherIndex(1), + /* [115] */ MatcherIndex(4), + /* [116] */ MatcherIndex(62), + /* [117] */ MatcherIndex(0), + /* [118] */ MatcherIndex(1), + /* [119] */ MatcherIndex(2), + /* [120] */ MatcherIndex(3), + /* [121] */ MatcherIndex(31), + /* [122] */ MatcherIndex(23), + /* [123] */ MatcherIndex(33), + /* [124] */ MatcherIndex(13), + /* [125] */ MatcherIndex(4), + /* [126] */ MatcherIndex(31), + /* [127] */ MatcherIndex(23), + /* [128] */ MatcherIndex(33), + /* [129] */ MatcherIndex(14), + /* [130] */ MatcherIndex(4), + /* [131] */ MatcherIndex(62), + /* [132] */ MatcherIndex(11), + /* [133] */ MatcherIndex(0), + /* [134] */ MatcherIndex(2), + /* [135] */ MatcherIndex(3), + /* [136] */ MatcherIndex(62), + /* [137] */ MatcherIndex(9), + /* [138] */ MatcherIndex(1), + /* [139] */ MatcherIndex(4), + /* [140] */ MatcherIndex(3), + /* [141] */ MatcherIndex(62), + /* [142] */ MatcherIndex(10), /* [143] */ MatcherIndex(1), - /* [144] */ MatcherIndex(28), - /* [145] */ MatcherIndex(1), - /* [146] */ MatcherIndex(68), - /* [147] */ MatcherIndex(2), - /* [148] */ MatcherIndex(0), - /* [149] */ MatcherIndex(66), - /* [150] */ MatcherIndex(12), - /* [151] */ MatcherIndex(0), - /* [152] */ MatcherIndex(1), - /* [153] */ MatcherIndex(2), - /* [154] */ MatcherIndex(66), - /* [155] */ MatcherIndex(13), - /* [156] */ MatcherIndex(0), - /* [157] */ MatcherIndex(1), - /* [158] */ MatcherIndex(2), - /* [159] */ MatcherIndex(66), - /* [160] */ MatcherIndex(14), - /* [161] */ MatcherIndex(0), - /* [162] */ MatcherIndex(1), - /* [163] */ MatcherIndex(2), - /* [164] */ MatcherIndex(27), - /* [165] */ MatcherIndex(0), - /* [166] */ MatcherIndex(0), - /* [167] */ MatcherIndex(1), - /* [168] */ MatcherIndex(27), + /* [144] */ MatcherIndex(2), + /* [145] */ MatcherIndex(4), + /* [146] */ MatcherIndex(62), + /* [147] */ MatcherIndex(11), + /* [148] */ MatcherIndex(1), + /* [149] */ MatcherIndex(2), + /* [150] */ MatcherIndex(3), + /* [151] */ MatcherIndex(62), + /* [152] */ MatcherIndex(9), + /* [153] */ MatcherIndex(0), + /* [154] */ MatcherIndex(4), + /* [155] */ MatcherIndex(3), + /* [156] */ MatcherIndex(62), + /* [157] */ MatcherIndex(10), + /* [158] */ MatcherIndex(0), + /* [159] */ MatcherIndex(2), + /* [160] */ MatcherIndex(4), + /* [161] */ MatcherIndex(62), + /* [162] */ MatcherIndex(0), + /* [163] */ MatcherIndex(10), + /* [164] */ MatcherIndex(1), + /* [165] */ MatcherIndex(2), + /* [166] */ MatcherIndex(62), + /* [167] */ MatcherIndex(0), + /* [168] */ MatcherIndex(11), /* [169] */ MatcherIndex(1), - /* [170] */ MatcherIndex(0), - /* [171] */ MatcherIndex(2), - /* [172] */ MatcherIndex(27), - /* [173] */ MatcherIndex(0), - /* [174] */ MatcherIndex(1), - /* [175] */ MatcherIndex(2), - /* [176] */ MatcherIndex(28), + /* [170] */ MatcherIndex(2), + /* [171] */ MatcherIndex(31), + /* [172] */ MatcherIndex(2), + /* [173] */ MatcherIndex(64), + /* [174] */ MatcherIndex(4), + /* [175] */ MatcherIndex(1), + /* [176] */ MatcherIndex(31), /* [177] */ MatcherIndex(2), - /* [178] */ MatcherIndex(0), - /* [179] */ MatcherIndex(1), - /* [180] */ MatcherIndex(28), - /* [181] */ MatcherIndex(2), - /* [182] */ MatcherIndex(67), - /* [183] */ MatcherIndex(1), - /* [184] */ MatcherIndex(28), - /* [185] */ MatcherIndex(1), - /* [186] */ MatcherIndex(67), - /* [187] */ MatcherIndex(0), - /* [188] */ MatcherIndex(27), + /* [178] */ MatcherIndex(64), + /* [179] */ MatcherIndex(3), + /* [180] */ MatcherIndex(1), + /* [181] */ MatcherIndex(31), + /* [182] */ MatcherIndex(1), + /* [183] */ MatcherIndex(64), + /* [184] */ MatcherIndex(2), + /* [185] */ MatcherIndex(0), + /* [186] */ MatcherIndex(62), + /* [187] */ MatcherIndex(9), + /* [188] */ MatcherIndex(0), /* [189] */ MatcherIndex(1), /* [190] */ MatcherIndex(2), - /* [191] */ MatcherIndex(0), - /* [192] */ MatcherIndex(27), - /* [193] */ MatcherIndex(2), - /* [194] */ MatcherIndex(3), - /* [195] */ MatcherIndex(0), - /* [196] */ MatcherIndex(27), - /* [197] */ MatcherIndex(1), - /* [198] */ MatcherIndex(3), - /* [199] */ MatcherIndex(0), - /* [200] */ MatcherIndex(27), - /* [201] */ MatcherIndex(2), - /* [202] */ MatcherIndex(1), + /* [191] */ MatcherIndex(62), + /* [192] */ MatcherIndex(10), + /* [193] */ MatcherIndex(0), + /* [194] */ MatcherIndex(1), + /* [195] */ MatcherIndex(2), + /* [196] */ MatcherIndex(62), + /* [197] */ MatcherIndex(11), + /* [198] */ MatcherIndex(0), + /* [199] */ MatcherIndex(1), + /* [200] */ MatcherIndex(2), + /* [201] */ MatcherIndex(30), + /* [202] */ MatcherIndex(0), /* [203] */ MatcherIndex(0), - /* [204] */ MatcherIndex(26), - /* [205] */ MatcherIndex(0), + /* [204] */ MatcherIndex(1), + /* [205] */ MatcherIndex(30), /* [206] */ MatcherIndex(1), - /* [207] */ MatcherIndex(26), - /* [208] */ MatcherIndex(0), - /* [209] */ MatcherIndex(6), - /* [210] */ MatcherIndex(26), + /* [207] */ MatcherIndex(0), + /* [208] */ MatcherIndex(2), + /* [209] */ MatcherIndex(30), + /* [210] */ MatcherIndex(0), /* [211] */ MatcherIndex(1), - /* [212] */ MatcherIndex(0), - /* [213] */ MatcherIndex(26), - /* [214] */ MatcherIndex(0), - /* [215] */ MatcherIndex(12), - /* [216] */ MatcherIndex(64), - /* [217] */ MatcherIndex(0), - /* [218] */ MatcherIndex(1), - /* [219] */ MatcherIndex(26), - /* [220] */ MatcherIndex(0), - /* [221] */ MatcherIndex(2), - /* [222] */ MatcherIndex(62), - /* [223] */ MatcherIndex(0), - /* [224] */ MatcherIndex(1), - /* [225] */ MatcherIndex(42), - /* [226] */ MatcherIndex(12), - /* [227] */ MatcherIndex(0), - /* [228] */ MatcherIndex(43), - /* [229] */ MatcherIndex(12), - /* [230] */ MatcherIndex(0), - /* [231] */ MatcherIndex(44), - /* [232] */ MatcherIndex(12), - /* [233] */ MatcherIndex(0), - /* [234] */ MatcherIndex(45), - /* [235] */ MatcherIndex(12), + /* [212] */ MatcherIndex(2), + /* [213] */ MatcherIndex(31), + /* [214] */ MatcherIndex(2), + /* [215] */ MatcherIndex(0), + /* [216] */ MatcherIndex(1), + /* [217] */ MatcherIndex(31), + /* [218] */ MatcherIndex(2), + /* [219] */ MatcherIndex(63), + /* [220] */ MatcherIndex(1), + /* [221] */ MatcherIndex(31), + /* [222] */ MatcherIndex(1), + /* [223] */ MatcherIndex(63), + /* [224] */ MatcherIndex(0), + /* [225] */ MatcherIndex(30), + /* [226] */ MatcherIndex(1), + /* [227] */ MatcherIndex(2), + /* [228] */ MatcherIndex(0), + /* [229] */ MatcherIndex(30), + /* [230] */ MatcherIndex(2), + /* [231] */ MatcherIndex(3), + /* [232] */ MatcherIndex(0), + /* [233] */ MatcherIndex(30), + /* [234] */ MatcherIndex(1), + /* [235] */ MatcherIndex(3), /* [236] */ MatcherIndex(0), - /* [237] */ MatcherIndex(46), - /* [238] */ MatcherIndex(12), - /* [239] */ MatcherIndex(0), - /* [240] */ MatcherIndex(47), - /* [241] */ MatcherIndex(12), + /* [237] */ MatcherIndex(30), + /* [238] */ MatcherIndex(2), + /* [239] */ MatcherIndex(1), + /* [240] */ MatcherIndex(0), + /* [241] */ MatcherIndex(29), /* [242] */ MatcherIndex(0), - /* [243] */ MatcherIndex(54), - /* [244] */ MatcherIndex(0), - /* [245] */ MatcherIndex(1), - /* [246] */ MatcherIndex(55), - /* [247] */ MatcherIndex(0), + /* [243] */ MatcherIndex(1), + /* [244] */ MatcherIndex(29), + /* [245] */ MatcherIndex(0), + /* [246] */ MatcherIndex(9), + /* [247] */ MatcherIndex(29), /* [248] */ MatcherIndex(1), - /* [249] */ MatcherIndex(56), - /* [250] */ MatcherIndex(0), + /* [249] */ MatcherIndex(0), + /* [250] */ MatcherIndex(29), /* [251] */ MatcherIndex(1), - /* [252] */ MatcherIndex(57), - /* [253] */ MatcherIndex(0), + /* [252] */ MatcherIndex(74), + /* [253] */ MatcherIndex(29), /* [254] */ MatcherIndex(1), - /* [255] */ MatcherIndex(59), - /* [256] */ MatcherIndex(0), + /* [255] */ MatcherIndex(2), + /* [256] */ MatcherIndex(29), /* [257] */ MatcherIndex(1), - /* [258] */ MatcherIndex(43), - /* [259] */ MatcherIndex(0), + /* [258] */ MatcherIndex(16), + /* [259] */ MatcherIndex(29), /* [260] */ MatcherIndex(1), - /* [261] */ MatcherIndex(43), - /* [262] */ MatcherIndex(0), - /* [263] */ MatcherIndex(6), - /* [264] */ MatcherIndex(43), - /* [265] */ MatcherIndex(0), - /* [266] */ MatcherIndex(7), - /* [267] */ MatcherIndex(43), - /* [268] */ MatcherIndex(0), - /* [269] */ MatcherIndex(2), - /* [270] */ MatcherIndex(44), - /* [271] */ MatcherIndex(0), - /* [272] */ MatcherIndex(3), - /* [273] */ MatcherIndex(44), - /* [274] */ MatcherIndex(0), - /* [275] */ MatcherIndex(6), - /* [276] */ MatcherIndex(44), - /* [277] */ MatcherIndex(0), - /* [278] */ MatcherIndex(7), - /* [279] */ MatcherIndex(46), - /* [280] */ MatcherIndex(0), - /* [281] */ MatcherIndex(1), - /* [282] */ MatcherIndex(46), - /* [283] */ MatcherIndex(0), - /* [284] */ MatcherIndex(6), - /* [285] */ MatcherIndex(46), - /* [286] */ MatcherIndex(0), - /* [287] */ MatcherIndex(7), - /* [288] */ MatcherIndex(47), - /* [289] */ MatcherIndex(0), - /* [290] */ MatcherIndex(3), - /* [291] */ MatcherIndex(47), - /* [292] */ MatcherIndex(0), - /* [293] */ MatcherIndex(6), - /* [294] */ MatcherIndex(47), - /* [295] */ MatcherIndex(0), - /* [296] */ MatcherIndex(7), - /* [297] */ MatcherIndex(42), - /* [298] */ MatcherIndex(12), - /* [299] */ MatcherIndex(6), - /* [300] */ MatcherIndex(42), - /* [301] */ MatcherIndex(12), - /* [302] */ MatcherIndex(7), - /* [303] */ MatcherIndex(43), - /* [304] */ MatcherIndex(12), - /* [305] */ MatcherIndex(6), - /* [306] */ MatcherIndex(43), - /* [307] */ MatcherIndex(12), - /* [308] */ MatcherIndex(7), - /* [309] */ MatcherIndex(44), - /* [310] */ MatcherIndex(12), - /* [311] */ MatcherIndex(6), - /* [312] */ MatcherIndex(44), - /* [313] */ MatcherIndex(12), - /* [314] */ MatcherIndex(7), - /* [315] */ MatcherIndex(45), - /* [316] */ MatcherIndex(12), - /* [317] */ MatcherIndex(6), - /* [318] */ MatcherIndex(45), - /* [319] */ MatcherIndex(12), - /* [320] */ MatcherIndex(7), - /* [321] */ MatcherIndex(46), - /* [322] */ MatcherIndex(12), - /* [323] */ MatcherIndex(6), - /* [324] */ MatcherIndex(46), - /* [325] */ MatcherIndex(12), - /* [326] */ MatcherIndex(7), - /* [327] */ MatcherIndex(47), - /* [328] */ MatcherIndex(12), - /* [329] */ MatcherIndex(6), - /* [330] */ MatcherIndex(47), - /* [331] */ MatcherIndex(12), - /* [332] */ MatcherIndex(7), - /* [333] */ MatcherIndex(44), - /* [334] */ MatcherIndex(12), - /* [335] */ MatcherIndex(1), - /* [336] */ MatcherIndex(47), - /* [337] */ MatcherIndex(12), - /* [338] */ MatcherIndex(1), - /* [339] */ MatcherIndex(54), - /* [340] */ MatcherIndex(1), - /* [341] */ MatcherIndex(2), - /* [342] */ MatcherIndex(55), - /* [343] */ MatcherIndex(1), - /* [344] */ MatcherIndex(2), - /* [345] */ MatcherIndex(56), - /* [346] */ MatcherIndex(1), - /* [347] */ MatcherIndex(2), - /* [348] */ MatcherIndex(57), - /* [349] */ MatcherIndex(1), - /* [350] */ MatcherIndex(2), - /* [351] */ MatcherIndex(59), - /* [352] */ MatcherIndex(1), - /* [353] */ MatcherIndex(2), - /* [354] */ MatcherIndex(42), + /* [261] */ MatcherIndex(12), + /* [262] */ MatcherIndex(29), + /* [263] */ MatcherIndex(0), + /* [264] */ MatcherIndex(15), + /* [265] */ MatcherIndex(60), + /* [266] */ MatcherIndex(0), + /* [267] */ MatcherIndex(1), + /* [268] */ MatcherIndex(29), + /* [269] */ MatcherIndex(0), + /* [270] */ MatcherIndex(2), + /* [271] */ MatcherIndex(58), + /* [272] */ MatcherIndex(0), + /* [273] */ MatcherIndex(1), + /* [274] */ MatcherIndex(29), + /* [275] */ MatcherIndex(0), + /* [276] */ MatcherIndex(14), + /* [277] */ MatcherIndex(50), + /* [278] */ MatcherIndex(0), + /* [279] */ MatcherIndex(1), + /* [280] */ MatcherIndex(51), + /* [281] */ MatcherIndex(0), + /* [282] */ MatcherIndex(1), + /* [283] */ MatcherIndex(52), + /* [284] */ MatcherIndex(0), + /* [285] */ MatcherIndex(1), + /* [286] */ MatcherIndex(53), + /* [287] */ MatcherIndex(0), + /* [288] */ MatcherIndex(1), + /* [289] */ MatcherIndex(55), + /* [290] */ MatcherIndex(0), + /* [291] */ MatcherIndex(1), + /* [292] */ MatcherIndex(50), + /* [293] */ MatcherIndex(1), + /* [294] */ MatcherIndex(2), + /* [295] */ MatcherIndex(51), + /* [296] */ MatcherIndex(1), + /* [297] */ MatcherIndex(2), + /* [298] */ MatcherIndex(52), + /* [299] */ MatcherIndex(1), + /* [300] */ MatcherIndex(2), + /* [301] */ MatcherIndex(53), + /* [302] */ MatcherIndex(1), + /* [303] */ MatcherIndex(2), + /* [304] */ MatcherIndex(55), + /* [305] */ MatcherIndex(1), + /* [306] */ MatcherIndex(2), + /* [307] */ MatcherIndex(29), + /* [308] */ MatcherIndex(2), + /* [309] */ MatcherIndex(0), + /* [310] */ MatcherIndex(29), + /* [311] */ MatcherIndex(1), + /* [312] */ MatcherIndex(9), + /* [313] */ MatcherIndex(29), + /* [314] */ MatcherIndex(1), + /* [315] */ MatcherIndex(14), + /* [316] */ MatcherIndex(19), + /* [317] */ MatcherIndex(16), + /* [318] */ MatcherIndex(17), + /* [319] */ MatcherIndex(1), + /* [320] */ MatcherIndex(17), + /* [321] */ MatcherIndex(12), + /* [322] */ MatcherIndex(19), + /* [323] */ MatcherIndex(12), + /* [324] */ MatcherIndex(17), + /* [325] */ MatcherIndex(14), + /* [326] */ MatcherIndex(18), + /* [327] */ MatcherIndex(0), + /* [328] */ MatcherIndex(59), + /* [329] */ MatcherIndex(0), + /* [330] */ MatcherIndex(57), + /* [331] */ MatcherIndex(0), + /* [332] */ MatcherIndex(17), + /* [333] */ MatcherIndex(15), + /* [334] */ MatcherIndex(19), + /* [335] */ MatcherIndex(15), + /* [336] */ MatcherIndex(19), + /* [337] */ MatcherIndex(13), + /* [338] */ MatcherIndex(19), + /* [339] */ MatcherIndex(14), + /* [340] */ MatcherIndex(38), + /* [341] */ MatcherIndex(0), + /* [342] */ MatcherIndex(39), + /* [343] */ MatcherIndex(0), + /* [344] */ MatcherIndex(40), + /* [345] */ MatcherIndex(0), + /* [346] */ MatcherIndex(18), + /* [347] */ MatcherIndex(14), + /* [348] */ MatcherIndex(41), + /* [349] */ MatcherIndex(0), + /* [350] */ MatcherIndex(42), + /* [351] */ MatcherIndex(0), + /* [352] */ MatcherIndex(43), + /* [353] */ MatcherIndex(0), + /* [354] */ MatcherIndex(44), /* [355] */ MatcherIndex(0), - /* [356] */ MatcherIndex(3), - /* [357] */ MatcherIndex(43), - /* [358] */ MatcherIndex(0), - /* [359] */ MatcherIndex(3), - /* [360] */ MatcherIndex(44), - /* [361] */ MatcherIndex(0), - /* [362] */ MatcherIndex(4), - /* [363] */ MatcherIndex(45), - /* [364] */ MatcherIndex(0), - /* [365] */ MatcherIndex(3), - /* [366] */ MatcherIndex(42), - /* [367] */ MatcherIndex(12), - /* [368] */ MatcherIndex(1), - /* [369] */ MatcherIndex(43), - /* [370] */ MatcherIndex(12), - /* [371] */ MatcherIndex(1), - /* [372] */ MatcherIndex(45), - /* [373] */ MatcherIndex(12), - /* [374] */ MatcherIndex(1), - /* [375] */ MatcherIndex(46), - /* [376] */ MatcherIndex(12), - /* [377] */ MatcherIndex(1), - /* [378] */ MatcherIndex(26), - /* [379] */ MatcherIndex(2), - /* [380] */ MatcherIndex(0), - /* [381] */ MatcherIndex(26), - /* [382] */ MatcherIndex(1), - /* [383] */ MatcherIndex(6), - /* [384] */ MatcherIndex(26), + /* [356] */ MatcherIndex(19), + /* [357] */ MatcherIndex(0), + /* [358] */ MatcherIndex(17), + /* [359] */ MatcherIndex(13), + /* [360] */ MatcherIndex(18), + /* [361] */ MatcherIndex(15), + /* [362] */ MatcherIndex(38), + /* [363] */ MatcherIndex(15), + /* [364] */ MatcherIndex(39), + /* [365] */ MatcherIndex(15), + /* [366] */ MatcherIndex(40), + /* [367] */ MatcherIndex(15), + /* [368] */ MatcherIndex(41), + /* [369] */ MatcherIndex(15), + /* [370] */ MatcherIndex(18), + /* [371] */ MatcherIndex(13), + /* [372] */ MatcherIndex(42), + /* [373] */ MatcherIndex(15), + /* [374] */ MatcherIndex(43), + /* [375] */ MatcherIndex(15), + /* [376] */ MatcherIndex(17), + /* [377] */ MatcherIndex(0), + /* [378] */ MatcherIndex(18), + /* [379] */ MatcherIndex(1), + /* [380] */ MatcherIndex(56), + /* [381] */ MatcherIndex(0), + /* [382] */ MatcherIndex(61), + /* [383] */ MatcherIndex(0), + /* [384] */ MatcherIndex(38), /* [385] */ MatcherIndex(1), - /* [386] */ MatcherIndex(11), - /* [387] */ MatcherIndex(15), - /* [388] */ MatcherIndex(0), - /* [389] */ MatcherIndex(63), - /* [390] */ MatcherIndex(0), - /* [391] */ MatcherIndex(61), - /* [392] */ MatcherIndex(0), - /* [393] */ MatcherIndex(14), - /* [394] */ MatcherIndex(12), - /* [395] */ MatcherIndex(16), - /* [396] */ MatcherIndex(12), - /* [397] */ MatcherIndex(16), - /* [398] */ MatcherIndex(10), - /* [399] */ MatcherIndex(16), - /* [400] */ MatcherIndex(11), - /* [401] */ MatcherIndex(36), - /* [402] */ MatcherIndex(0), - /* [403] */ MatcherIndex(14), - /* [404] */ MatcherIndex(11), - /* [405] */ MatcherIndex(37), - /* [406] */ MatcherIndex(0), - /* [407] */ MatcherIndex(38), - /* [408] */ MatcherIndex(0), + /* [386] */ MatcherIndex(39), + /* [387] */ MatcherIndex(1), + /* [388] */ MatcherIndex(40), + /* [389] */ MatcherIndex(1), + /* [390] */ MatcherIndex(41), + /* [391] */ MatcherIndex(1), + /* [392] */ MatcherIndex(42), + /* [393] */ MatcherIndex(1), + /* [394] */ MatcherIndex(43), + /* [395] */ MatcherIndex(1), + /* [396] */ MatcherIndex(44), + /* [397] */ MatcherIndex(1), + /* [398] */ MatcherIndex(19), + /* [399] */ MatcherIndex(1), + /* [400] */ MatcherIndex(20), + /* [401] */ MatcherIndex(0), + /* [402] */ MatcherIndex(20), + /* [403] */ MatcherIndex(15), + /* [404] */ MatcherIndex(20), + /* [405] */ MatcherIndex(16), + /* [406] */ MatcherIndex(21), + /* [407] */ MatcherIndex(0), + /* [408] */ MatcherIndex(21), /* [409] */ MatcherIndex(15), - /* [410] */ MatcherIndex(11), - /* [411] */ MatcherIndex(39), - /* [412] */ MatcherIndex(0), - /* [413] */ MatcherIndex(40), - /* [414] */ MatcherIndex(0), - /* [415] */ MatcherIndex(41), - /* [416] */ MatcherIndex(0), - /* [417] */ MatcherIndex(48), - /* [418] */ MatcherIndex(0), - /* [419] */ MatcherIndex(16), - /* [420] */ MatcherIndex(0), - /* [421] */ MatcherIndex(35), - /* [422] */ MatcherIndex(2), - /* [423] */ MatcherIndex(35), - /* [424] */ MatcherIndex(1), - /* [425] */ MatcherIndex(35), - /* [426] */ MatcherIndex(9), - /* [427] */ MatcherIndex(14), - /* [428] */ MatcherIndex(10), - /* [429] */ MatcherIndex(35), - /* [430] */ MatcherIndex(3), - /* [431] */ MatcherIndex(15), - /* [432] */ MatcherIndex(12), - /* [433] */ MatcherIndex(36), - /* [434] */ MatcherIndex(12), - /* [435] */ MatcherIndex(35), - /* [436] */ MatcherIndex(0), - /* [437] */ MatcherIndex(37), - /* [438] */ MatcherIndex(12), - /* [439] */ MatcherIndex(38), - /* [440] */ MatcherIndex(12), - /* [441] */ MatcherIndex(39), - /* [442] */ MatcherIndex(12), - /* [443] */ MatcherIndex(15), - /* [444] */ MatcherIndex(10), - /* [445] */ MatcherIndex(40), - /* [446] */ MatcherIndex(12), - /* [447] */ MatcherIndex(41), - /* [448] */ MatcherIndex(12), - /* [449] */ MatcherIndex(15), - /* [450] */ MatcherIndex(1), - /* [451] */ MatcherIndex(60), - /* [452] */ MatcherIndex(0), - /* [453] */ MatcherIndex(65), - /* [454] */ MatcherIndex(0), - /* [455] */ MatcherIndex(36), - /* [456] */ MatcherIndex(1), - /* [457] */ MatcherIndex(37), - /* [458] */ MatcherIndex(1), - /* [459] */ MatcherIndex(38), - /* [460] */ MatcherIndex(1), - /* [461] */ MatcherIndex(39), - /* [462] */ MatcherIndex(1), - /* [463] */ MatcherIndex(40), - /* [464] */ MatcherIndex(1), - /* [465] */ MatcherIndex(41), - /* [466] */ MatcherIndex(1), - /* [467] */ MatcherIndex(48), - /* [468] */ MatcherIndex(1), - /* [469] */ MatcherIndex(16), - /* [470] */ MatcherIndex(1), - /* [471] */ MatcherIndex(17), - /* [472] */ MatcherIndex(0), - /* [473] */ MatcherIndex(17), - /* [474] */ MatcherIndex(12), - /* [475] */ MatcherIndex(17), - /* [476] */ MatcherIndex(13), - /* [477] */ MatcherIndex(18), - /* [478] */ MatcherIndex(0), - /* [479] */ MatcherIndex(18), - /* [480] */ MatcherIndex(12), - /* [481] */ MatcherIndex(18), - /* [482] */ MatcherIndex(13), - /* [483] */ MatcherIndex(19), - /* [484] */ MatcherIndex(0), - /* [485] */ MatcherIndex(19), - /* [486] */ MatcherIndex(12), - /* [487] */ MatcherIndex(19), - /* [488] */ MatcherIndex(13), - /* [489] */ MatcherIndex(20), - /* [490] */ MatcherIndex(13), - /* [491] */ MatcherIndex(23), - /* [492] */ MatcherIndex(0), - /* [493] */ MatcherIndex(23), - /* [494] */ MatcherIndex(12), - /* [495] */ MatcherIndex(23), - /* [496] */ MatcherIndex(13), - /* [497] */ MatcherIndex(24), - /* [498] */ MatcherIndex(0), - /* [499] */ MatcherIndex(24), - /* [500] */ MatcherIndex(12), - /* [501] */ MatcherIndex(24), - /* [502] */ MatcherIndex(13), - /* [503] */ MatcherIndex(25), - /* [504] */ MatcherIndex(0), - /* [505] */ MatcherIndex(25), - /* [506] */ MatcherIndex(12), - /* [507] */ MatcherIndex(25), - /* [508] */ MatcherIndex(13), - /* [509] */ MatcherIndex(76), - /* [510] */ MatcherIndex(80), - /* [511] */ MatcherIndex(81), - /* [512] */ MatcherIndex(70), - /* [513] */ MatcherIndex(78), - /* [514] */ MatcherIndex(77), - /* [515] */ MatcherIndex(49), - /* [516] */ MatcherIndex(50), - /* [517] */ MatcherIndex(51), - /* [518] */ MatcherIndex(52), - /* [519] */ MatcherIndex(53), - /* [520] */ MatcherIndex(58), - /* [521] */ MatcherIndex(33), - /* [522] */ MatcherIndex(34), - /* [523] */ MatcherIndex(82), - /* [524] */ MatcherIndex(83), - /* [525] */ MatcherIndex(73), - /* [526] */ MatcherIndex(74), - /* [527] */ MatcherIndex(71), - /* [528] */ MatcherIndex(72), - /* [529] */ MatcherIndex(75), - /* [530] */ MatcherIndex(84), + /* [410] */ MatcherIndex(21), + /* [411] */ MatcherIndex(16), + /* [412] */ MatcherIndex(22), + /* [413] */ MatcherIndex(0), + /* [414] */ MatcherIndex(22), + /* [415] */ MatcherIndex(15), + /* [416] */ MatcherIndex(22), + /* [417] */ MatcherIndex(16), + /* [418] */ MatcherIndex(23), + /* [419] */ MatcherIndex(0), + /* [420] */ MatcherIndex(23), + /* [421] */ MatcherIndex(15), + /* [422] */ MatcherIndex(23), + /* [423] */ MatcherIndex(16), + /* [424] */ MatcherIndex(24), + /* [425] */ MatcherIndex(0), + /* [426] */ MatcherIndex(24), + /* [427] */ MatcherIndex(15), + /* [428] */ MatcherIndex(24), + /* [429] */ MatcherIndex(16), + /* [430] */ MatcherIndex(25), + /* [431] */ MatcherIndex(0), + /* [432] */ MatcherIndex(25), + /* [433] */ MatcherIndex(15), + /* [434] */ MatcherIndex(25), + /* [435] */ MatcherIndex(16), + /* [436] */ MatcherIndex(26), + /* [437] */ MatcherIndex(0), + /* [438] */ MatcherIndex(26), + /* [439] */ MatcherIndex(15), + /* [440] */ MatcherIndex(26), + /* [441] */ MatcherIndex(16), + /* [442] */ MatcherIndex(27), + /* [443] */ MatcherIndex(0), + /* [444] */ MatcherIndex(27), + /* [445] */ MatcherIndex(15), + /* [446] */ MatcherIndex(27), + /* [447] */ MatcherIndex(16), + /* [448] */ MatcherIndex(28), + /* [449] */ MatcherIndex(0), + /* [450] */ MatcherIndex(28), + /* [451] */ MatcherIndex(15), + /* [452] */ MatcherIndex(28), + /* [453] */ MatcherIndex(16), + /* [454] */ MatcherIndex(73), + /* [455] */ MatcherIndex(77), + /* [456] */ MatcherIndex(78), + /* [457] */ MatcherIndex(66), + /* [458] */ MatcherIndex(75), + /* [459] */ MatcherIndex(45), + /* [460] */ MatcherIndex(46), + /* [461] */ MatcherIndex(47), + /* [462] */ MatcherIndex(48), + /* [463] */ MatcherIndex(49), + /* [464] */ MatcherIndex(54), + /* [465] */ MatcherIndex(36), + /* [466] */ MatcherIndex(37), + /* [467] */ MatcherIndex(79), + /* [468] */ MatcherIndex(80), + /* [469] */ MatcherIndex(69), + /* [470] */ MatcherIndex(70), + /* [471] */ MatcherIndex(67), + /* [472] */ MatcherIndex(68), + /* [473] */ MatcherIndex(71), + /* [474] */ MatcherIndex(72), + /* [475] */ MatcherIndex(81), }; static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices), @@ -2725,6043 +2460,3343 @@ constexpr ParameterInfo kParameters[] = { /* [0] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(47), + /* matcher_indices */ MatcherIndicesIndex(59), }, { /* [1] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [2] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [3] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [4] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [5] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [6] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [7] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [8] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [9] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [10] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [11] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [12] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [13] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [14] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [15] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [16] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [17] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [18] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [19] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), + /* matcher_indices */ MatcherIndicesIndex(366), }, { /* [20] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [21] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [22] */ /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [23] */ /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [24] */ /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [25] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [26] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(39), }, { /* [27] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), + /* matcher_indices */ MatcherIndicesIndex(344), }, { /* [28] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [29] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [30] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(3), }, { /* [31] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [32] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(460), }, { /* [33] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(333), + /* matcher_indices */ MatcherIndicesIndex(466), }, { /* [34] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [35] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [36] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [37] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [38] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(366), }, { /* [39] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [40] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(309), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [41] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [42] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [43] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [44] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(364), }, { /* [45] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [46] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [47] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(312), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [48] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [49] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [50] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(368), }, { /* [51] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [52] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [53] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [54] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [55] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(407), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(370), }, { /* [56] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(374), }, { /* [57] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [58] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [59] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [60] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [61] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(407), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [62] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), + /* matcher_indices */ MatcherIndicesIndex(366), }, { /* [63] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [64] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [65] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [66] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [67] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [68] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(460), }, { /* [69] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [70] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [71] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [72] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), }, { /* [73] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(273), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [74] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(39), }, { /* [75] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(342), }, { /* [76] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [77] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [78] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [79] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(276), + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(39), }, { /* [80] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), + /* matcher_indices */ MatcherIndicesIndex(352), }, { /* [81] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [82] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [83] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), }, { /* [84] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(516), + /* matcher_indices */ MatcherIndicesIndex(460), }, { /* [85] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(522), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [86] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [87] */ /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [88] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [89] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(459), }, { /* [90] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), + /* matcher_indices */ MatcherIndicesIndex(466), }, { /* [91] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [92] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [93] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [94] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(462), }, { /* [95] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), }, { /* [96] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [97] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [98] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [99] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(366), }, { /* [100] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [101] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [102] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(333), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [103] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [104] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(364), }, { /* [105] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [106] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [107] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [108] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(309), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [109] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), + /* matcher_indices */ MatcherIndicesIndex(368), }, { /* [110] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [111] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [112] */ /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [113] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* matcher_indices */ MatcherIndicesIndex(370), }, { /* [114] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(312), + /* matcher_indices */ MatcherIndicesIndex(374), }, { /* [115] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [116] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [117] */ /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [118] */ /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [119] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(372), }, { /* [120] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [121] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [122] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [123] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [124] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(364), }, { /* [125] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [126] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [127] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [128] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [129] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(368), }, { /* [130] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [131] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [132] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(228), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [133] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(370), }, { /* [134] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(374), }, { /* [135] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [136] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [137] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [138] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(303), + /* matcher_indices */ MatcherIndicesIndex(264), }, { /* [139] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), + /* matcher_indices */ MatcherIndicesIndex(459), }, { /* [140] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [141] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(332), }, { /* [142] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [143] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [144] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(306), + /* matcher_indices */ MatcherIndicesIndex(462), }, { /* [145] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), + /* matcher_indices */ MatcherIndicesIndex(465), }, { /* [146] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(360), }, { /* [147] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(57), }, { /* [148] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(39), }, { /* [149] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(111), }, { /* [150] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [151] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(116), }, { /* [152] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), }, { /* [153] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [154] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(36), }, { /* [155] */ /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [156] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), + /* matcher_indices */ MatcherIndicesIndex(116), }, { /* [157] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), }, { /* [158] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [159] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(121), }, { /* [160] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [161] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(116), }, { /* [162] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(234), + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), }, { /* [163] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [164] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(126), }, { /* [165] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [166] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), + /* matcher_indices */ MatcherIndicesIndex(116), }, { /* [167] */ - /* usage */ core::ParameterUsage::kOffset, + /* usage */ core::ParameterUsage::kColMajor, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), + /* matcher_indices */ MatcherIndicesIndex(137), }, { /* [168] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(315), + /* matcher_indices */ MatcherIndicesIndex(15), }, { /* [169] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [170] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [171] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [172] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [173] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [174] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(318), - }, - { - /* [175] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [176] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [177] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [178] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [179] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [180] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [181] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [182] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [183] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [184] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [185] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [186] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [187] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [188] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [189] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [190] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [191] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [192] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(336), - }, - { - /* [193] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [194] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [195] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [196] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [197] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [198] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(327), - }, - { - /* [199] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [200] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [201] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [202] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [203] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [204] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(330), - }, - { - /* [205] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [206] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [207] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [208] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [209] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [210] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), - }, - { - /* [211] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [212] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [213] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [214] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [215] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [216] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), - }, - { - /* [217] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [218] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [219] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [220] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [221] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [222] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(333), - }, - { - /* [223] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [224] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [225] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [226] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [227] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [228] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(309), - }, - { - /* [229] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [230] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [231] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [232] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [233] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [234] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(312), - }, - { - /* [235] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [236] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [237] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [238] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [239] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [240] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(516), - }, - { - /* [241] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [242] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [243] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [244] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [245] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [246] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [247] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(405), - }, - { - /* [248] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [249] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [250] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [251] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [252] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(405), - }, - { - /* [253] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [254] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [255] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [256] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [257] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(267), - }, - { - /* [258] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [259] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [260] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [261] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [262] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(261), - }, - { - /* [263] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [264] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [265] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [266] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [267] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(264), - }, - { - /* [268] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [269] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [270] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [271] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [272] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(415), - }, - { - /* [273] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [274] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [275] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [276] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [277] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(415), - }, - { - /* [278] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), - }, - { - /* [279] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [280] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [281] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [282] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(288), - }, - { - /* [283] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [284] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [285] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [286] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [287] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(291), - }, - { - /* [288] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), - }, - { - /* [289] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [290] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [291] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [292] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(294), - }, - { - /* [293] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [294] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [295] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [296] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(516), - }, - { - /* [297] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [298] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [299] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [300] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [301] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), - }, - { - /* [302] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(522), - }, - { - /* [303] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [304] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [305] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [306] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(518), - }, - { - /* [307] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(522), - }, - { - /* [308] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [309] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [310] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [311] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), - }, - { - /* [312] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [313] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [314] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [315] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [316] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), - }, - { - /* [317] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [318] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [319] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [320] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [321] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(231), - }, - { - /* [322] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [323] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [324] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [325] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [326] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(309), - }, - { - /* [327] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [328] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [329] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [330] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [331] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(312), - }, - { - /* [332] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [333] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [334] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [335] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [336] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [337] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [338] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [339] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [340] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [341] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [342] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [343] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [344] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [345] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [346] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(228), - }, - { - /* [347] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [348] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [349] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [350] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [351] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(303), - }, - { - /* [352] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [353] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [354] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [355] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [356] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(306), - }, - { - /* [357] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [358] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [359] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [360] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [361] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [362] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [363] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [364] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [365] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [366] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [367] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [368] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [369] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [370] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [371] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(234), - }, - { - /* [372] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [373] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [374] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [375] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [376] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(315), - }, - { - /* [377] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [378] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [379] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [380] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [381] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(318), - }, - { - /* [382] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [383] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [384] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [385] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [386] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [387] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [388] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [389] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [390] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [391] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [392] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [393] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [394] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [395] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [396] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(336), - }, - { - /* [397] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [398] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [399] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [400] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [401] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(327), - }, - { - /* [402] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [403] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [404] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [405] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [406] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(330), - }, - { - /* [407] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [408] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [409] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [410] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [411] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [412] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [413] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [414] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [415] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [416] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [417] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [418] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [419] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [420] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [421] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(237), - }, - { - /* [422] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [423] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [424] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [425] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [426] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(321), - }, - { - /* [427] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [428] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [429] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [430] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [431] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(321), - }, - { - /* [432] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [433] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [434] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [435] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [436] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [437] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [438] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [439] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [440] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [441] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [442] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [443] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [444] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [445] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [446] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(228), - }, - { - /* [447] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [448] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [449] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [450] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [451] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(303), - }, - { - /* [452] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [453] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [454] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [455] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [456] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(306), - }, - { - /* [457] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [458] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [459] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [460] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [461] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [462] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [463] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [464] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [465] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [466] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [467] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [468] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [469] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [470] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [471] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(234), - }, - { - /* [472] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [473] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [474] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [475] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [476] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(315), - }, - { - /* [477] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [478] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [479] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [480] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [481] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(318), - }, - { - /* [482] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [483] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [484] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [485] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [486] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [487] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [488] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [489] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [490] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [491] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [492] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [493] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [494] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [495] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [496] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(336), - }, - { - /* [497] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [498] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [499] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [500] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [501] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(327), - }, - { - /* [502] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [503] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [504] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [505] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [506] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(330), - }, - { - /* [507] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [508] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [509] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [510] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [511] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), - }, - { - /* [512] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [513] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [514] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [515] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [516] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(518), - }, - { - /* [517] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [518] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [519] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [520] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [521] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(79), - }, - { - /* [522] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [523] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [524] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [525] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [526] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(21), - }, - { - /* [527] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [528] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [529] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [530] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [531] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(89), - }, - { - /* [532] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [533] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [534] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [535] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [536] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(94), - }, - { - /* [537] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [538] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [539] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [540] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [541] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(28), - }, - { - /* [542] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [543] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [544] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [545] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [546] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(35), - }, - { - /* [547] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [548] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [549] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [550] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [551] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [552] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [553] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [554] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [555] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [556] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(258), - }, - { - /* [557] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [558] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [559] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [560] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(261), - }, - { - /* [561] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [562] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [563] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [564] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(413), - }, - { - /* [565] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [566] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [567] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [568] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(413), - }, - { - /* [569] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [570] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [571] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [572] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(279), - }, - { - /* [573] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [574] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [575] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [576] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(282), - }, - { - /* [577] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [578] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [579] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [580] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(285), - }, - { - /* [581] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [582] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [583] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), - }, - { - /* [584] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [585] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [586] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [587] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(517), - }, - { - /* [588] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(522), - }, - { - /* [589] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [590] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [591] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [592] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [593] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [594] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [595] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [596] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [597] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [598] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [599] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(228), - }, - { - /* [600] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [601] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [602] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [603] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(303), - }, - { - /* [604] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [605] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [606] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [607] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(306), - }, - { - /* [608] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [609] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [610] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [611] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [612] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [613] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [614] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [615] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [616] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [617] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [618] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [619] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(234), - }, - { - /* [620] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [621] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [622] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [623] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(315), - }, - { - /* [624] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [625] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [626] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [627] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(318), - }, - { - /* [628] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [629] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [630] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [631] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [632] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [633] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [634] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [635] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(240), - }, - { - /* [636] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [637] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [638] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [639] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(327), - }, - { - /* [640] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [641] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [642] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [643] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [644] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [645] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [646] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [647] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [648] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [649] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [650] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [651] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(237), - }, - { - /* [652] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [653] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [654] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [655] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(321), - }, - { - /* [656] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [657] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [658] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [659] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(324), - }, - { - /* [660] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [661] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [662] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [663] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(433), - }, - { - /* [664] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [665] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [666] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [667] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(433), - }, - { - /* [668] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [669] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [670] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [671] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(225), - }, - { - /* [672] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [673] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [674] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [675] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(297), - }, - { - /* [676] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [677] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [678] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [679] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(300), - }, - { - /* [680] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [681] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [682] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [683] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [684] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [685] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [686] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [687] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [688] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [689] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [690] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [691] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(237), - }, - { - /* [692] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [693] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [694] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [695] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(321), - }, - { - /* [696] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [697] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [698] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [699] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(324), - }, - { - /* [700] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [701] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [702] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), - }, - { - /* [703] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(517), - }, - { - /* [704] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [705] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(431), - }, - { - /* [706] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [707] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(345), - }, - { - /* [708] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [709] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [710] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(395), - }, - { - /* [711] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(345), - }, - { - /* [712] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [713] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [714] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), - }, - { - /* [715] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(345), - }, - { - /* [716] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [717] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [718] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(399), - }, - { - /* [719] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(407), - }, - { - /* [720] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(115), - }, - { - /* [721] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [722] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [723] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(360), - }, - { - /* [724] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(115), - }, - { - /* [725] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [726] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [727] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(516), - }, - { - /* [728] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [729] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [730] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [731] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(64), - }, - { - /* [732] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [733] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [734] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [735] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(0), - }, - { - /* [736] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [737] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [738] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [739] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(69), - }, - { - /* [740] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [741] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [742] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [743] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(74), - }, - { - /* [744] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [745] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [746] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [747] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(7), - }, - { - /* [748] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [749] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [750] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [751] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(14), - }, - { - /* [752] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [753] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [754] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [755] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [756] */ - /* usage */ core::ParameterUsage::kY, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [757] */ - /* usage */ core::ParameterUsage::kZ, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [758] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [759] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [760] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [761] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [762] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [763] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [764] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [765] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [766] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [767] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [768] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [769] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [770] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [771] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [772] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [773] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [774] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [775] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [776] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [777] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [778] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [779] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [780] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [781] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [782] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(209), - }, - { - /* [783] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [784] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [785] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(207), - }, - { - /* [786] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(207), - }, - { - /* [787] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(520), - }, - { - /* [788] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), - }, - { - /* [789] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), - }, - { - /* [790] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(339), - }, - { - /* [791] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [792] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(395), - }, - { - /* [793] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(342), - }, - { - /* [794] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [795] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(395), - }, - { - /* [796] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(348), - }, - { - /* [797] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [798] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(395), - }, - { - /* [799] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(351), - }, - { - /* [800] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [801] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(395), - }, - { - /* [802] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(339), - }, - { - /* [803] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [804] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), - }, - { - /* [805] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(342), - }, - { - /* [806] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [807] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), - }, - { - /* [808] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(348), - }, - { - /* [809] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [810] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), - }, - { - /* [811] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(351), - }, - { - /* [812] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [813] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), - }, - { - /* [814] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(339), - }, - { - /* [815] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [816] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(399), - }, - { - /* [817] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(342), - }, - { - /* [818] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [819] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(399), - }, - { - /* [820] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(348), - }, - { - /* [821] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [822] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(399), - }, - { - /* [823] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(351), - }, - { - /* [824] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [825] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(399), - }, - { - /* [826] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(401), - }, - { - /* [827] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [828] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [829] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(405), - }, - { - /* [830] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(115), - }, - { - /* [831] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [832] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [833] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [834] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [835] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(354), - }, - { - /* [836] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [837] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [838] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(357), - }, - { - /* [839] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(115), - }, - { - /* [840] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [841] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(363), - }, - { - /* [842] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [843] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [844] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [845] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(115), - }, - { - /* [846] */ - /* usage */ core::ParameterUsage::kSampleIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [847] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), - }, - { - /* [848] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [849] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [850] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(519), - }, - { - /* [851] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [852] */ - /* usage */ core::ParameterUsage::kSampleIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [853] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(119), - }, - { - /* [854] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(124), - }, - { - /* [855] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(114), - }, - { - /* [856] */ - /* usage */ core::ParameterUsage::kXy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [857] */ - /* usage */ core::ParameterUsage::kZ, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [858] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [859] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [860] */ - /* usage */ core::ParameterUsage::kYz, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [861] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [862] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [863] */ - /* usage */ core::ParameterUsage::kY, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [864] */ - /* usage */ core::ParameterUsage::kZw, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [865] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [866] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [867] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [868] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(219), - }, - { - /* [869] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(401), - }, - { - /* [870] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [871] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(405), - }, - { - /* [872] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [873] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(407), - }, - { - /* [874] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [875] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [876] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [877] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(413), - }, - { - /* [878] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [879] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(415), - }, - { - /* [880] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [881] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(225), - }, - { - /* [882] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [883] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(228), - }, - { - /* [884] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [885] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(231), - }, - { - /* [886] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [887] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(234), - }, - { - /* [888] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [889] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(237), - }, - { - /* [890] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [891] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(240), - }, - { - /* [892] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [893] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), - }, - { - /* [894] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [895] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(516), - }, - { - /* [896] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [897] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(517), - }, - { - /* [898] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [899] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(518), - }, - { - /* [900] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [901] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(520), - }, - { - /* [902] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [903] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(53), - }, - { - /* [904] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(56), - }, - { - /* [905] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [906] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(511), - }, - { - /* [907] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [908] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(511), - }, - { - /* [909] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [910] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(511), - }, - { - /* [911] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [912] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(511), - }, - { - /* [913] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [914] */ - /* usage */ core::ParameterUsage::kMask, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [915] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [916] */ - /* usage */ core::ParameterUsage::kMask, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [917] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [918] */ - /* usage */ core::ParameterUsage::kDelta, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [919] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [920] */ - /* usage */ core::ParameterUsage::kDelta, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [921] */ - /* usage */ core::ParameterUsage::kE, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [922] */ - /* usage */ core::ParameterUsage::kId, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(511), - }, - { - /* [923] */ - /* usage */ core::ParameterUsage::kE, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [924] */ - /* usage */ core::ParameterUsage::kId, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(511), - }, - { - /* [925] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(104), - }, - { - /* [926] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(109), - }, - { - /* [927] */ - /* usage */ core::ParameterUsage::kM, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(84), - }, - { - /* [928] */ - /* usage */ core::ParameterUsage::kS, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), - }, - { - /* [929] */ - /* usage */ core::ParameterUsage::kM, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(129), - }, - { - /* [930] */ - /* usage */ core::ParameterUsage::kS, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [931] */ - /* usage */ core::ParameterUsage::kM, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(134), - }, - { - /* [932] */ - /* usage */ core::ParameterUsage::kS, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [933] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), - }, - { - /* [934] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [935] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(139), - }, - { - /* [936] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(62), - }, - { - /* [937] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [938] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [939] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [940] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(384), - }, - { - /* [941] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(188), - }, - { - /* [942] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(188), - }, - { - /* [943] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [944] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(188), - }, - { - /* [945] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [946] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(378), - }, - { - /* [947] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(188), - }, - { - /* [948] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(196), - }, - { - /* [949] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), - }, - { - /* [950] */ - /* usage */ core::ParameterUsage::kXy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [951] */ - /* usage */ core::ParameterUsage::kZw, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [952] */ - /* usage */ core::ParameterUsage::kXyz, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [953] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [954] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [955] */ - /* usage */ core::ParameterUsage::kZyw, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(387), - }, - { - /* [956] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(42), }, { - /* [957] */ - /* usage */ core::ParameterUsage::kNone, + /* [170] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(164), + /* matcher_indices */ MatcherIndicesIndex(15), }, { - /* [958] */ + /* [171] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(116), }, { - /* [959] */ + /* [172] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [173] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [174] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(213), + /* matcher_indices */ MatcherIndicesIndex(48), }, { - /* [960] */ + /* [175] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [176] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(393), + /* matcher_indices */ MatcherIndicesIndex(116), }, { - /* [961] */ + /* [177] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [178] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [179] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(395), + /* matcher_indices */ MatcherIndicesIndex(241), }, { - /* [962] */ + /* [180] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), + /* matcher_indices */ MatcherIndicesIndex(241), }, { - /* [963] */ + /* [181] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(399), + /* matcher_indices */ MatcherIndicesIndex(15), }, { - /* [964] */ + /* [182] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(172), + /* matcher_indices */ MatcherIndicesIndex(15), }, { - /* [965] */ + /* [183] */ + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [184] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(243), + /* matcher_indices */ MatcherIndicesIndex(350), }, { - /* [966] */ + /* [185] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(465), + }, + { + /* [186] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(360), + }, + { + /* [187] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(246), + /* matcher_indices */ MatcherIndicesIndex(459), }, { - /* [967] */ + /* [188] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(465), + }, + { + /* [189] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), + }, + { + /* [190] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), + }, + { + /* [191] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(249), + /* matcher_indices */ MatcherIndicesIndex(461), }, { - /* [968] */ + /* [192] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), + }, + { + /* [193] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(360), + }, + { + /* [194] */ + /* usage */ core::ParameterUsage::kDepthRef, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(264), + }, + { + /* [195] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(252), + /* matcher_indices */ MatcherIndicesIndex(364), }, { - /* [969] */ + /* [196] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(465), + }, + { + /* [197] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), + }, + { + /* [198] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(358), + }, + { + /* [199] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(255), + /* matcher_indices */ MatcherIndicesIndex(368), }, { - /* [970] */ - /* usage */ core::ParameterUsage::kInputAttachment, + /* [200] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(451), + /* matcher_indices */ MatcherIndicesIndex(465), }, { - /* [971] */ - /* usage */ core::ParameterUsage::kNone, + /* [201] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(184), + /* matcher_indices */ MatcherIndicesIndex(360), }, { - /* [972] */ - /* usage */ core::ParameterUsage::kNone, + /* [202] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(370), + }, + { + /* [203] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(144), + /* matcher_indices */ MatcherIndicesIndex(372), }, { - /* [973] */ - /* usage */ core::ParameterUsage::kIndex, + /* [204] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), + /* matcher_indices */ MatcherIndicesIndex(465), }, { - /* [974] */ - /* usage */ core::ParameterUsage::kIndex, + /* [205] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(24), + /* matcher_indices */ MatcherIndicesIndex(360), }, { - /* [975] */ - /* usage */ core::ParameterUsage::kNone, + /* [206] */ + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(264), }, { - /* [976] */ - /* usage */ core::ParameterUsage::kNone, + /* [207] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(362), }, { - /* [977] */ - /* usage */ core::ParameterUsage::kNone, + /* [208] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(115), + /* matcher_indices */ MatcherIndicesIndex(465), }, { - /* [978] */ - /* usage */ core::ParameterUsage::kNone, + /* [209] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(449), + /* matcher_indices */ MatcherIndicesIndex(264), }, { - /* [979] */ - /* usage */ core::ParameterUsage::kNone, + /* [210] */ + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), + /* matcher_indices */ MatcherIndicesIndex(264), }, { - /* [980] */ - /* usage */ core::ParameterUsage::kNone, + /* [211] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), + /* matcher_indices */ MatcherIndicesIndex(372), }, { - /* [981] */ - /* usage */ core::ParameterUsage::kNone, + /* [212] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(473), + /* matcher_indices */ MatcherIndicesIndex(465), }, { - /* [982] */ - /* usage */ core::ParameterUsage::kNone, + /* [213] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(475), + /* matcher_indices */ MatcherIndicesIndex(360), }, { - /* [983] */ - /* usage */ core::ParameterUsage::kNone, + /* [214] */ + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(477), + /* matcher_indices */ MatcherIndicesIndex(264), }, { - /* [984] */ - /* usage */ core::ParameterUsage::kNone, + /* [215] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(479), + /* matcher_indices */ MatcherIndicesIndex(461), }, { - /* [985] */ - /* usage */ core::ParameterUsage::kNone, + /* [216] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(481), + /* matcher_indices */ MatcherIndicesIndex(465), }, { - /* [986] */ - /* usage */ core::ParameterUsage::kNone, + /* [217] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(483), + /* matcher_indices */ MatcherIndicesIndex(360), }, { - /* [987] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(485), - }, - { - /* [988] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(487), - }, - { - /* [989] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(51), - }, - { - /* [990] */ - /* usage */ core::ParameterUsage::kNone, + /* [218] */ + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(57), }, { - /* [991] */ - /* usage */ core::ParameterUsage::kNone, + /* [219] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(489), + /* matcher_indices */ MatcherIndicesIndex(298), }, { - /* [992] */ - /* usage */ core::ParameterUsage::kNone, + /* [220] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(5), + /* matcher_indices */ MatcherIndicesIndex(376), }, { - /* [993] */ + /* [221] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [222] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(334), + }, + { + /* [223] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(298), + }, + { + /* [224] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [225] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [226] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(336), + }, + { + /* [227] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(298), + }, + { + /* [228] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [229] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [230] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(338), + }, + { + /* [231] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(344), + }, + { + /* [232] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(318), + }, + { + /* [233] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [234] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [235] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(460), + }, + { + /* [236] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [237] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [238] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [239] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(76), + }, + { + /* [240] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [241] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [242] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [243] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(0), + }, + { + /* [244] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [245] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [246] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [247] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(81), + }, + { + /* [248] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [249] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [250] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [251] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(86), + }, + { + /* [252] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [253] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [254] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [255] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(6), + }, + { + /* [256] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [257] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [258] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [259] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(12), }, { - /* [994] */ - /* usage */ core::ParameterUsage::kNone, + /* [260] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(19), + /* matcher_indices */ MatcherIndicesIndex(15), }, { - /* [995] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(26), + /* [261] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(137), }, { - /* [996] */ - /* usage */ core::ParameterUsage::kNone, + /* [262] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(33), + /* matcher_indices */ MatcherIndicesIndex(15), }, { - /* [997] */ + /* [263] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(76), + }, + { + /* [264] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [265] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(71), + }, + { + /* [266] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [267] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(0), + }, + { + /* [268] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [269] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(71), + }, + { + /* [270] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [271] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(81), + }, + { + /* [272] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [273] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(71), + }, + { + /* [274] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [275] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(86), + }, + { + /* [276] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [277] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(71), + }, + { + /* [278] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [279] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(6), + }, + { + /* [280] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [281] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(71), + }, + { + /* [282] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [283] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(12), + }, + { + /* [284] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [285] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(71), + }, + { + /* [286] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [287] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(217), + }, + { + /* [288] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [289] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(40), }, { - /* [998] */ + /* [290] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(491), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [999] */ + /* [291] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(493), + /* matcher_indices */ MatcherIndicesIndex(176), }, { - /* [1000] */ + /* [292] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(495), + /* matcher_indices */ MatcherIndicesIndex(40), }, { - /* [1001] */ + /* [293] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(497), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1002] */ + /* [294] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(499), + /* matcher_indices */ MatcherIndicesIndex(1), }, { - /* [1003] */ - /* usage */ core::ParameterUsage::kNone, + /* [295] */ + /* usage */ core::ParameterUsage::kX, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(501), + /* matcher_indices */ MatcherIndicesIndex(57), }, { - /* [1004] */ - /* usage */ core::ParameterUsage::kNone, + /* [296] */ + /* usage */ core::ParameterUsage::kY, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(503), + /* matcher_indices */ MatcherIndicesIndex(57), }, { - /* [1005] */ - /* usage */ core::ParameterUsage::kNone, + /* [297] */ + /* usage */ core::ParameterUsage::kZ, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(505), + /* matcher_indices */ MatcherIndicesIndex(57), }, { - /* [1006] */ + /* [298] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [299] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(507), + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [300] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [301] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [302] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [303] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [304] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [305] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [306] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [307] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(356), + }, + { + /* [308] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(356), + }, + { + /* [309] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(356), + }, + { + /* [310] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(356), + }, + { + /* [311] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [312] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [313] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [314] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [315] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [316] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [317] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [318] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [319] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [320] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [321] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [322] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(137), + }, + { + /* [323] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [324] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [325] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(244), + }, + { + /* [326] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(244), + }, + { + /* [327] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(464), + }, + { + /* [328] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(465), + }, + { + /* [329] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), + }, + { + /* [330] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(292), + }, + { + /* [331] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [332] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(334), + }, + { + /* [333] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(295), + }, + { + /* [334] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [335] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(334), + }, + { + /* [336] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(301), + }, + { + /* [337] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [338] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(334), + }, + { + /* [339] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(304), + }, + { + /* [340] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [341] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(334), + }, + { + /* [342] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(292), + }, + { + /* [343] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [344] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(336), + }, + { + /* [345] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(295), + }, + { + /* [346] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [347] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(336), + }, + { + /* [348] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(301), + }, + { + /* [349] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [350] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(336), + }, + { + /* [351] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(304), + }, + { + /* [352] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [353] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(336), + }, + { + /* [354] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(292), + }, + { + /* [355] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [356] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(338), + }, + { + /* [357] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(295), + }, + { + /* [358] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [359] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(338), + }, + { + /* [360] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(301), + }, + { + /* [361] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [362] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(338), + }, + { + /* [363] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(304), + }, + { + /* [364] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [365] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(338), + }, + { + /* [366] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(340), + }, + { + /* [367] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [368] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [369] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(342), + }, + { + /* [370] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(318), + }, + { + /* [371] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [372] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(348), + }, + { + /* [373] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(378), + }, + { + /* [374] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [375] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(354), + }, + { + /* [376] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(318), + }, + { + /* [377] */ + /* usage */ core::ParameterUsage::kSampleIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [378] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(459), + }, + { + /* [379] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [380] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [381] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(463), + }, + { + /* [382] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [383] */ + /* usage */ core::ParameterUsage::kSampleIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [384] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(96), + }, + { + /* [385] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [386] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [387] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(18), + }, + { + /* [388] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [389] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [390] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(101), + }, + { + /* [391] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [392] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [393] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(106), + }, + { + /* [394] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [395] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [396] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(24), + }, + { + /* [397] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [398] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [399] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(30), + }, + { + /* [400] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [401] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [402] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [403] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(156), + }, + { + /* [404] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(146), + }, + { + /* [405] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(171), + }, + { + /* [406] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [407] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [408] */ + /* usage */ core::ParameterUsage::kXy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [409] */ + /* usage */ core::ParameterUsage::kZ, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [410] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [411] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [412] */ + /* usage */ core::ParameterUsage::kYz, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [413] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [414] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [415] */ + /* usage */ core::ParameterUsage::kY, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [416] */ + /* usage */ core::ParameterUsage::kZw, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [417] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [418] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [419] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [420] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(268), + }, + { + /* [421] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(274), + }, + { + /* [422] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(274), + }, + { + /* [423] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(340), + }, + { + /* [424] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [425] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(342), + }, + { + /* [426] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [427] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(344), + }, + { + /* [428] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [429] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(348), + }, + { + /* [430] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [431] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(350), + }, + { + /* [432] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [433] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(352), + }, + { + /* [434] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [435] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(459), + }, + { + /* [436] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [437] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(460), + }, + { + /* [438] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [439] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(461), + }, + { + /* [440] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [441] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(462), + }, + { + /* [442] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [443] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(464), + }, + { + /* [444] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [445] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(65), + }, + { + /* [446] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(68), + }, + { + /* [447] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(68), + }, + { + /* [448] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [449] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(456), + }, + { + /* [450] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [451] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(456), + }, + { + /* [452] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [453] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(456), + }, + { + /* [454] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [455] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(456), + }, + { + /* [456] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [457] */ + /* usage */ core::ParameterUsage::kMask, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [458] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [459] */ + /* usage */ core::ParameterUsage::kMask, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [460] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [461] */ + /* usage */ core::ParameterUsage::kDelta, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [462] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [463] */ + /* usage */ core::ParameterUsage::kDelta, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [464] */ + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [465] */ + /* usage */ core::ParameterUsage::kId, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(456), + }, + { + /* [466] */ + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(241), + }, + { + /* [467] */ + /* usage */ core::ParameterUsage::kId, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(456), + }, + { + /* [468] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(136), + }, + { + /* [469] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(141), + }, + { + /* [470] */ + /* usage */ core::ParameterUsage::kM, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(116), + }, + { + /* [471] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [472] */ + /* usage */ core::ParameterUsage::kM, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(161), + }, + { + /* [473] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [474] */ + /* usage */ core::ParameterUsage::kM, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(166), + }, + { + /* [475] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [476] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(221), + }, + { + /* [477] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [478] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(181), + }, + { + /* [479] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), + }, + { + /* [480] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [481] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [482] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [483] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(313), + }, + { + /* [484] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(225), + }, + { + /* [485] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(225), + }, + { + /* [486] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [487] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(225), + }, + { + /* [488] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [489] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(307), + }, + { + /* [490] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(225), + }, + { + /* [491] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(233), + }, + { + /* [492] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(237), + }, + { + /* [493] */ + /* usage */ core::ParameterUsage::kXy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [494] */ + /* usage */ core::ParameterUsage::kZw, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(376), + }, + { + /* [495] */ + /* usage */ core::ParameterUsage::kXyz, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [496] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [497] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(57), + }, + { + /* [498] */ + /* usage */ core::ParameterUsage::kZyw, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(326), + }, + { + /* [499] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(54), + }, + { + /* [500] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(64), + }, + { + /* [501] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(63), + }, + { + /* [502] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(316), + }, + { + /* [503] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [504] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(256), + }, + { + /* [505] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(318), + }, + { + /* [506] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(261), + }, + { + /* [507] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(259), + }, + { + /* [508] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(320), + }, + { + /* [509] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(322), + }, + { + /* [510] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(324), + }, + { + /* [511] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(201), + }, + { + /* [512] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(264), + }, + { + /* [513] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(262), + }, + { + /* [514] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(332), + }, + { + /* [515] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(334), + }, + { + /* [516] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(336), + }, + { + /* [517] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(338), + }, + { + /* [518] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(209), + }, + { + /* [519] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(277), + }, + { + /* [520] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(280), + }, + { + /* [521] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(283), + }, + { + /* [522] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(286), + }, + { + /* [523] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(289), + }, + { + /* [524] */ + /* usage */ core::ParameterUsage::kInputAttachment, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(380), + }, + { + /* [525] */ + /* usage */ core::ParameterUsage::kIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [526] */ + /* usage */ core::ParameterUsage::kIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(39), + }, + { + /* [527] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [528] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(378), + }, + { + /* [529] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(398), + }, + { + /* [530] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(400), + }, + { + /* [531] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(402), + }, + { + /* [532] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(404), + }, + { + /* [533] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(406), + }, + { + /* [534] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(408), + }, + { + /* [535] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(410), + }, + { + /* [536] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(412), + }, + { + /* [537] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(414), + }, + { + /* [538] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(416), + }, + { + /* [539] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(418), + }, + { + /* [540] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(420), + }, + { + /* [541] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(422), + }, + { + /* [542] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(424), + }, + { + /* [543] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(426), + }, + { + /* [544] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(428), + }, + { + /* [545] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(430), + }, + { + /* [546] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(432), + }, + { + /* [547] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(434), + }, + { + /* [548] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(436), + }, + { + /* [549] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(438), + }, + { + /* [550] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(440), + }, + { + /* [551] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(442), + }, + { + /* [552] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(444), + }, + { + /* [553] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(446), + }, + { + /* [554] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(448), + }, + { + /* [555] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(450), + }, + { + /* [556] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(452), }, }; @@ -8772,325 +5807,325 @@ constexpr TemplateInfo kTemplates[] = { { /* [0] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(59), + /* matcher_indices */ MatcherIndicesIndex(91), /* kind */ TemplateInfo::Kind::kType, }, { /* [1] */ - /* name */ "K", + /* name */ "Majorness", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [2] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(509), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [3] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(454), + /* kind */ TemplateInfo::Kind::kType, }, { /* [4] */ - /* name */ "R", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [5] */ - /* name */ "AC", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [6] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(59), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [7] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [8] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(131), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [9] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [10] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [11] */ /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [12] */ + /* [7] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [8] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [9] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(59), + /* matcher_indices */ MatcherIndicesIndex(91), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [10] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, + { + /* [11] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [12] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(142), /* kind */ TemplateInfo::Kind::kType, }, { /* [13] */ - /* name */ "K", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [14] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(136), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [15] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [16] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [17] */ + /* [15] */ /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [16] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [17] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, + }, { /* [18] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(91), /* kind */ TemplateInfo::Kind::kType, }, { /* [19] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [20] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [21] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(132), /* kind */ TemplateInfo::Kind::kType, }, { /* [22] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [23] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [24] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [25] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [26] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [27] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(510), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [28] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [29] */ /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [30] */ + /* [23] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [24] */ + /* name */ "AC", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [25] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [26] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [27] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(71), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [28] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [29] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(454), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [30] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, { /* [31] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [32] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(509), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AC", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [33] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [34] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [35] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(13), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(71), /* kind */ TemplateInfo::Kind::kType, }, { /* [36] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [37] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(142), + /* kind */ TemplateInfo::Kind::kType, }, { /* [38] */ - /* name */ "R", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [39] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [40] */ - /* name */ "C", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [41] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [42] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(523), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [43] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(524), + /* matcher_indices */ MatcherIndicesIndex(71), /* kind */ TemplateInfo::Kind::kType, }, { /* [44] */ - /* name */ "C", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [45] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(132), + /* kind */ TemplateInfo::Kind::kType, }, { /* [46] */ - /* name */ "K", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [47] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [48] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [49] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [50] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [51] */ - /* name */ "K", + /* [48] */ + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [49] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [50] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [51] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, { /* [52] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [53] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(510), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(454), /* kind */ TemplateInfo::Kind::kType, }, { @@ -9107,1352 +6142,2072 @@ constexpr TemplateInfo kTemplates[] = { }, { /* [56] */ - /* name */ "K", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [57] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [58] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(13), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [59] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, + { + /* [60] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [61] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(142), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [62] */ /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [60] */ + /* [63] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [61] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [62] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(524), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [63] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(523), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [64] */ - /* name */ "C", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [65] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [66] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [67] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [68] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [69] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(132), + /* kind */ TemplateInfo::Kind::kType, }, { /* [70] */ - /* name */ "R", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [71] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [72] */ - /* name */ "T", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kType, + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [73] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(477), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [74] */ - /* name */ "AS", - /* matcher_indices */ MatcherIndicesIndex(503), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [75] */ - /* name */ "O", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(91), /* kind */ TemplateInfo::Kind::kType, }, { /* [76] */ - /* name */ "N", + /* name */ "Majorness", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [77] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(510), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [78] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(10), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(454), /* kind */ TemplateInfo::Kind::kType, }, { /* [79] */ - /* name */ "T", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kType, + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [80] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(51), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [81] */ - /* name */ "AS", - /* matcher_indices */ MatcherIndicesIndex(1), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [82] */ - /* name */ "O", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(91), /* kind */ TemplateInfo::Kind::kType, }, { /* [83] */ - /* name */ "N", + /* name */ "Majorness", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [84] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(509), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [85] */ - /* name */ "N", + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(142), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [86] */ + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [86] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [87] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [88] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(514), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [89] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(91), /* kind */ TemplateInfo::Kind::kType, }, { /* [90] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [91] */ /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [92] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(132), /* kind */ TemplateInfo::Kind::kType, }, { /* [93] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [94] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [95] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [96] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [97] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [98] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(412), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [99] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [100] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [101] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(387), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [102] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(26), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [103] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(261), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [104] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [105] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(395), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [106] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(26), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [107] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [108] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [109] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(471), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [110] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(26), + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [111] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [112] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(514), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [113] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [114] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [115] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [116] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [117] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(71), /* kind */ TemplateInfo::Kind::kType, }, { /* [118] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [119] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(454), + /* kind */ TemplateInfo::Kind::kType, }, { /* [120] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [121] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(387), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [122] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(477), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [123] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(71), /* kind */ TemplateInfo::Kind::kType, }, { /* [124] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [125] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(395), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(142), + /* kind */ TemplateInfo::Kind::kType, }, { /* [126] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(477), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [127] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [128] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [129] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(471), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(71), + /* kind */ TemplateInfo::Kind::kType, }, { /* [130] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(477), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [131] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(132), /* kind */ TemplateInfo::Kind::kType, }, { /* [132] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [133] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(387), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [134] */ - /* name */ "RW", - /* matcher_indices */ MatcherIndicesIndex(51), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(326), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [135] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [136] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [137] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(395), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(454), + /* kind */ TemplateInfo::Kind::kType, }, { /* [138] */ - /* name */ "RW", - /* matcher_indices */ MatcherIndicesIndex(51), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [139] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [140] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [141] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(471), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [142] */ - /* name */ "RW", - /* matcher_indices */ MatcherIndicesIndex(51), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [143] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(142), /* kind */ TemplateInfo::Kind::kType, }, { /* [144] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(510), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [145] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [146] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [147] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, + { + /* [148] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [149] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(132), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [150] */ /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [147] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [148] */ - /* name */ "M", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [149] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [150] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(510), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [151] */ - /* name */ "N", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [152] */ - /* name */ "M", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [153] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(514), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [154] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [155] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(412), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [156] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [157] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [158] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [159] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [160] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [161] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [162] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [163] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [164] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [165] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [166] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [167] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [168] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(261), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [169] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(514), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [170] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [171] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [172] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(514), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [173] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(412), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [174] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [175] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(477), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [176] */ - /* name */ "AS", - /* matcher_indices */ MatcherIndicesIndex(503), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [177] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [178] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(512), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [176] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [177] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [178] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, + }, { /* [179] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [180] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(513), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [181] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [182] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(51), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [183] */ - /* name */ "AS", - /* matcher_indices */ MatcherIndicesIndex(1), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [184] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [185] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(455), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [186] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [187] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [188] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(457), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [189] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(455), /* kind */ TemplateInfo::Kind::kType, }, { /* [190] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(64), /* kind */ TemplateInfo::Kind::kType, }, { /* [191] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(459), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [192] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [193] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [194] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(461), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(264), /* kind */ TemplateInfo::Kind::kType, }, { /* [195] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(264), /* kind */ TemplateInfo::Kind::kType, }, { /* [196] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [197] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(463), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [198] */ /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [199] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(467), /* kind */ TemplateInfo::Kind::kType, }, { /* [200] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(465), + /* matcher_indices */ MatcherIndicesIndex(468), /* kind */ TemplateInfo::Kind::kType, }, { /* [201] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [202] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [203] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(467), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [204] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(514), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [205] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [206] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(366), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [207] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [208] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [209] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(369), + /* matcher_indices */ MatcherIndicesIndex(64), /* kind */ TemplateInfo::Kind::kType, }, { /* [210] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(455), + /* kind */ TemplateInfo::Kind::kType, }, { /* [211] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [212] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(333), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [213] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [214] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(264), /* kind */ TemplateInfo::Kind::kType, }, { /* [215] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(372), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(264), /* kind */ TemplateInfo::Kind::kType, }, { /* [216] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [217] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [218] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(375), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [219] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(468), + /* kind */ TemplateInfo::Kind::kType, }, { /* [220] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [221] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(336), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [222] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [223] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [224] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(423), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [225] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [226] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [227] */ - /* name */ "T", + /* name */ "TR", /* matcher_indices */ MatcherIndicesIndex(467), /* kind */ TemplateInfo::Kind::kType, }, { - /* [228] */ + /* [221] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [222] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [223] */ /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(511), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [224] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [225] */ + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [226] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [227] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [228] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, { /* [229] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [230] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(510), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [231] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(412), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [232] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [233] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(530), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [234] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(261), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [235] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "RW", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [236] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(530), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [237] */ - /* name */ "C", + /* name */ "T", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kType, }, { /* [238] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [239] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(530), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [240] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [241] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [242] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [241] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [242] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, { /* [243] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "RW", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [244] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(514), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [245] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(70), /* kind */ TemplateInfo::Kind::kType, }, { /* [246] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [247] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(511), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [248] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [249] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(477), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, }, { /* [250] */ /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [251] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(26), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "RW", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [252] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(515), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [253] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [254] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(516), + /* matcher_indices */ MatcherIndicesIndex(454), /* kind */ TemplateInfo::Kind::kType, }, { /* [255] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [256] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(517), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [257] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [258] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(518), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(412), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [259] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [260] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(519), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [261] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [262] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(522), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [263] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [264] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(511), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [265] */ /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [260] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [261] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [262] */ + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [263] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [264] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [265] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, { /* [266] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(13), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(456), /* kind */ TemplateInfo::Kind::kType, }, { /* [267] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(527), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(455), /* kind */ TemplateInfo::Kind::kType, }, { /* [268] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [269] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(528), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [270] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(10), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [271] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(525), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [272] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(430), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [273] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(526), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [274] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(209), + /* matcher_indices */ MatcherIndicesIndex(250), /* kind */ TemplateInfo::Kind::kType, }, { /* [275] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(529), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [276] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(525), + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(70), /* kind */ TemplateInfo::Kind::kType, }, { /* [277] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(526), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [278] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(527), + /* matcher_indices */ MatcherIndicesIndex(455), /* kind */ TemplateInfo::Kind::kType, }, { /* [279] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(528), + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(9), /* kind */ TemplateInfo::Kind::kType, }, { /* [280] */ + /* name */ "M", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [281] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [282] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(529), + /* matcher_indices */ MatcherIndicesIndex(455), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [283] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [284] */ + /* name */ "M", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [285] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [286] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [287] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [288] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [289] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [290] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [291] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [292] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [293] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [294] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [295] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(412), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [296] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [297] */ + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [298] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [299] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [300] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(384), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [301] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [302] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [303] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(386), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [304] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [305] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [306] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(388), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [307] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [308] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [309] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(390), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [310] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [311] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [312] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(392), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [313] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [314] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [315] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(394), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [316] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [317] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [318] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(396), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [319] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [320] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [321] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(396), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [322] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [323] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [324] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(455), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [325] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [326] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [327] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [328] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [329] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [330] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [331] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [332] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [333] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [334] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [335] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [336] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [337] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(454), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [338] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [339] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [340] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(406), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [341] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [342] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [343] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(256), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [344] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [345] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(457), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [346] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [347] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(458), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [348] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [349] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(63), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [350] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [351] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [352] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [353] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(259), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [354] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [355] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(320), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [356] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [357] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(322), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [358] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [359] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(70), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [360] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [361] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [362] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [363] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [364] */ + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(316), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [365] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(459), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [366] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [367] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(460), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [368] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [369] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [370] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [371] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(462), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [372] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [373] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(463), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [374] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [375] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(465), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [376] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [377] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(466), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [378] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [379] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(456), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [380] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [381] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(264), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [382] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(471), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [383] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(64), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [384] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(472), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [385] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(261), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [386] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(474), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [387] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [388] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(469), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [389] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [390] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(470), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [391] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(137), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [392] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(473), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [393] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(69), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [394] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(68), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [395] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(469), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [396] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(470), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [397] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(471), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [398] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(472), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [399] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(473), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [400] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(474), /* kind */ TemplateInfo::Kind::kType, }, }; @@ -10471,109 +8226,111 @@ constexpr core::constant::Eval::Function kConstEvalFunctions[] = { /* [7] */ &core::constant::Eval::atan, /* [8] */ &core::constant::Eval::atan2, /* [9] */ &core::constant::Eval::atanh, - /* [10] */ &core::constant::Eval::ceil, - /* [11] */ &core::constant::Eval::clamp, - /* [12] */ &core::constant::Eval::cos, - /* [13] */ &core::constant::Eval::cosh, - /* [14] */ &core::constant::Eval::countLeadingZeros, - /* [15] */ &core::constant::Eval::countOneBits, - /* [16] */ &core::constant::Eval::countTrailingZeros, - /* [17] */ &core::constant::Eval::cross, - /* [18] */ &core::constant::Eval::degrees, - /* [19] */ &core::constant::Eval::determinant, - /* [20] */ &core::constant::Eval::distance, - /* [21] */ &core::constant::Eval::dot, - /* [22] */ &core::constant::Eval::dot4I8Packed, - /* [23] */ &core::constant::Eval::dot4U8Packed, - /* [24] */ &core::constant::Eval::exp, - /* [25] */ &core::constant::Eval::exp2, - /* [26] */ &core::constant::Eval::extractBits, - /* [27] */ &core::constant::Eval::faceForward, - /* [28] */ &core::constant::Eval::firstLeadingBit, - /* [29] */ &core::constant::Eval::firstTrailingBit, - /* [30] */ &core::constant::Eval::floor, - /* [31] */ &core::constant::Eval::fma, - /* [32] */ &core::constant::Eval::fract, - /* [33] */ &core::constant::Eval::frexp, - /* [34] */ &core::constant::Eval::insertBits, - /* [35] */ &core::constant::Eval::inverseSqrt, - /* [36] */ &core::constant::Eval::ldexp, - /* [37] */ &core::constant::Eval::length, - /* [38] */ &core::constant::Eval::log, - /* [39] */ &core::constant::Eval::log2, - /* [40] */ &core::constant::Eval::max, - /* [41] */ &core::constant::Eval::min, - /* [42] */ &core::constant::Eval::mix, - /* [43] */ &core::constant::Eval::modf, - /* [44] */ &core::constant::Eval::normalize, - /* [45] */ &core::constant::Eval::pack2x16float, - /* [46] */ &core::constant::Eval::pack2x16snorm, - /* [47] */ &core::constant::Eval::pack2x16unorm, - /* [48] */ &core::constant::Eval::pack4x8snorm, - /* [49] */ &core::constant::Eval::pack4x8unorm, - /* [50] */ &core::constant::Eval::pack4xI8, - /* [51] */ &core::constant::Eval::pack4xU8, - /* [52] */ &core::constant::Eval::pack4xI8Clamp, - /* [53] */ &core::constant::Eval::pack4xU8Clamp, - /* [54] */ &core::constant::Eval::pow, - /* [55] */ &core::constant::Eval::quantizeToF16, - /* [56] */ &core::constant::Eval::radians, - /* [57] */ &core::constant::Eval::reflect, - /* [58] */ &core::constant::Eval::refract, - /* [59] */ &core::constant::Eval::reverseBits, - /* [60] */ &core::constant::Eval::round, - /* [61] */ &core::constant::Eval::saturate, - /* [62] */ &core::constant::Eval::select_bool, - /* [63] */ &core::constant::Eval::select_boolvec, - /* [64] */ &core::constant::Eval::sign, - /* [65] */ &core::constant::Eval::sin, - /* [66] */ &core::constant::Eval::sinh, - /* [67] */ &core::constant::Eval::smoothstep, - /* [68] */ &core::constant::Eval::sqrt, - /* [69] */ &core::constant::Eval::step, - /* [70] */ &core::constant::Eval::tan, - /* [71] */ &core::constant::Eval::tanh, - /* [72] */ &core::constant::Eval::transpose, - /* [73] */ &core::constant::Eval::trunc, - /* [74] */ &core::constant::Eval::unpack2x16float, - /* [75] */ &core::constant::Eval::unpack2x16snorm, - /* [76] */ &core::constant::Eval::unpack2x16unorm, - /* [77] */ &core::constant::Eval::unpack4x8snorm, - /* [78] */ &core::constant::Eval::unpack4x8unorm, - /* [79] */ &core::constant::Eval::unpack4xI8, - /* [80] */ &core::constant::Eval::unpack4xU8, - /* [81] */ &core::constant::Eval::Not, - /* [82] */ &core::constant::Eval::Complement, - /* [83] */ &core::constant::Eval::UnaryMinus, - /* [84] */ &core::constant::Eval::Plus, - /* [85] */ &core::constant::Eval::Minus, - /* [86] */ &core::constant::Eval::Multiply, - /* [87] */ &core::constant::Eval::MultiplyMatVec, - /* [88] */ &core::constant::Eval::MultiplyVecMat, - /* [89] */ &core::constant::Eval::MultiplyMatMat, - /* [90] */ &core::constant::Eval::Divide, - /* [91] */ &core::constant::Eval::Modulo, - /* [92] */ &core::constant::Eval::Xor, - /* [93] */ &core::constant::Eval::And, - /* [94] */ &core::constant::Eval::Or, - /* [95] */ &core::constant::Eval::LogicalAnd, - /* [96] */ &core::constant::Eval::LogicalOr, - /* [97] */ &core::constant::Eval::Equal, - /* [98] */ &core::constant::Eval::NotEqual, - /* [99] */ &core::constant::Eval::LessThan, - /* [100] */ &core::constant::Eval::GreaterThan, - /* [101] */ &core::constant::Eval::LessThanEqual, - /* [102] */ &core::constant::Eval::GreaterThanEqual, - /* [103] */ &core::constant::Eval::ShiftLeft, - /* [104] */ &core::constant::Eval::ShiftRight, - /* [105] */ &core::constant::Eval::Zero, - /* [106] */ &core::constant::Eval::Identity, - /* [107] */ &core::constant::Eval::Conv, - /* [108] */ &core::constant::Eval::VecSplat, - /* [109] */ &core::constant::Eval::VecInitS, - /* [110] */ &core::constant::Eval::VecInitM, - /* [111] */ &core::constant::Eval::MatInitS, - /* [112] */ &core::constant::Eval::MatInitV, + /* [10] */ &core::constant::Eval::bitcast, + /* [11] */ &core::constant::Eval::ceil, + /* [12] */ &core::constant::Eval::clamp, + /* [13] */ &core::constant::Eval::cos, + /* [14] */ &core::constant::Eval::cosh, + /* [15] */ &core::constant::Eval::countLeadingZeros, + /* [16] */ &core::constant::Eval::countOneBits, + /* [17] */ &core::constant::Eval::countTrailingZeros, + /* [18] */ &core::constant::Eval::cross, + /* [19] */ &core::constant::Eval::degrees, + /* [20] */ &core::constant::Eval::determinant, + /* [21] */ &core::constant::Eval::distance, + /* [22] */ &core::constant::Eval::dot, + /* [23] */ &core::constant::Eval::dot4I8Packed, + /* [24] */ &core::constant::Eval::dot4U8Packed, + /* [25] */ &core::constant::Eval::exp, + /* [26] */ &core::constant::Eval::exp2, + /* [27] */ &core::constant::Eval::extractBits, + /* [28] */ &core::constant::Eval::faceForward, + /* [29] */ &core::constant::Eval::firstLeadingBit, + /* [30] */ &core::constant::Eval::firstTrailingBit, + /* [31] */ &core::constant::Eval::floor, + /* [32] */ &core::constant::Eval::fma, + /* [33] */ &core::constant::Eval::fract, + /* [34] */ &core::constant::Eval::frexp, + /* [35] */ &core::constant::Eval::insertBits, + /* [36] */ &core::constant::Eval::inverseSqrt, + /* [37] */ &core::constant::Eval::ldexp, + /* [38] */ &core::constant::Eval::length, + /* [39] */ &core::constant::Eval::log, + /* [40] */ &core::constant::Eval::log2, + /* [41] */ &core::constant::Eval::max, + /* [42] */ &core::constant::Eval::min, + /* [43] */ &core::constant::Eval::mix, + /* [44] */ &core::constant::Eval::modf, + /* [45] */ &core::constant::Eval::normalize, + /* [46] */ &core::constant::Eval::pack2x16float, + /* [47] */ &core::constant::Eval::pack2x16snorm, + /* [48] */ &core::constant::Eval::pack2x16unorm, + /* [49] */ &core::constant::Eval::pack4x8snorm, + /* [50] */ &core::constant::Eval::pack4x8unorm, + /* [51] */ &core::constant::Eval::pack4xI8, + /* [52] */ &core::constant::Eval::pack4xU8, + /* [53] */ &core::constant::Eval::pack4xI8Clamp, + /* [54] */ &core::constant::Eval::pack4xU8Clamp, + /* [55] */ &core::constant::Eval::pow, + /* [56] */ &core::constant::Eval::quantizeToF16, + /* [57] */ &core::constant::Eval::radians, + /* [58] */ &core::constant::Eval::reflect, + /* [59] */ &core::constant::Eval::refract, + /* [60] */ &core::constant::Eval::reverseBits, + /* [61] */ &core::constant::Eval::round, + /* [62] */ &core::constant::Eval::saturate, + /* [63] */ &core::constant::Eval::select_bool, + /* [64] */ &core::constant::Eval::select_boolvec, + /* [65] */ &core::constant::Eval::sign, + /* [66] */ &core::constant::Eval::sin, + /* [67] */ &core::constant::Eval::sinh, + /* [68] */ &core::constant::Eval::smoothstep, + /* [69] */ &core::constant::Eval::sqrt, + /* [70] */ &core::constant::Eval::step, + /* [71] */ &core::constant::Eval::tan, + /* [72] */ &core::constant::Eval::tanh, + /* [73] */ &core::constant::Eval::transpose, + /* [74] */ &core::constant::Eval::trunc, + /* [75] */ &core::constant::Eval::unpack2x16float, + /* [76] */ &core::constant::Eval::unpack2x16snorm, + /* [77] */ &core::constant::Eval::unpack2x16unorm, + /* [78] */ &core::constant::Eval::unpack4x8snorm, + /* [79] */ &core::constant::Eval::unpack4x8unorm, + /* [80] */ &core::constant::Eval::unpack4xI8, + /* [81] */ &core::constant::Eval::unpack4xU8, + /* [82] */ &core::constant::Eval::addSat, + /* [83] */ &core::constant::Eval::Not, + /* [84] */ &core::constant::Eval::Complement, + /* [85] */ &core::constant::Eval::UnaryMinus, + /* [86] */ &core::constant::Eval::Plus, + /* [87] */ &core::constant::Eval::Minus, + /* [88] */ &core::constant::Eval::Multiply, + /* [89] */ &core::constant::Eval::MultiplyMatVec, + /* [90] */ &core::constant::Eval::MultiplyVecMat, + /* [91] */ &core::constant::Eval::MultiplyMatMat, + /* [92] */ &core::constant::Eval::Divide, + /* [93] */ &core::constant::Eval::Modulo, + /* [94] */ &core::constant::Eval::Xor, + /* [95] */ &core::constant::Eval::And, + /* [96] */ &core::constant::Eval::Or, + /* [97] */ &core::constant::Eval::LogicalAnd, + /* [98] */ &core::constant::Eval::LogicalOr, + /* [99] */ &core::constant::Eval::Equal, + /* [100] */ &core::constant::Eval::NotEqual, + /* [101] */ &core::constant::Eval::LessThan, + /* [102] */ &core::constant::Eval::GreaterThan, + /* [103] */ &core::constant::Eval::LessThanEqual, + /* [104] */ &core::constant::Eval::GreaterThanEqual, + /* [105] */ &core::constant::Eval::ShiftLeft, + /* [106] */ &core::constant::Eval::ShiftRight, + /* [107] */ &core::constant::Eval::Zero, + /* [108] */ &core::constant::Eval::Identity, + /* [109] */ &core::constant::Eval::Conv, + /* [110] */ &core::constant::Eval::VecSplat, + /* [111] */ &core::constant::Eval::VecInitS, + /* [112] */ &core::constant::Eval::VecInitM, + /* [113] */ &core::constant::Eval::MatInitS, + /* [114] */ &core::constant::Eval::MatInitV, }; static_assert(ConstEvalFunctionIndex::CanIndex(kConstEvalFunctions), @@ -10582,2906 +8339,2906 @@ static_assert(ConstEvalFunctionIndex::CanIndex(kConstEvalFunctions), constexpr OverloadInfo kOverloads[] = { { /* [0] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(663), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(285), + /* parameters */ ParameterIndex(366), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [1] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(667), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(285), + /* parameters */ ParameterIndex(369), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [2] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(231), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [3] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(675), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(285), + /* parameters */ ParameterIndex(372), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [4] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(679), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(288), + /* parameters */ ParameterIndex(375), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [5] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(260), + /* parameters */ ParameterIndex(378), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [6] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(246), + /* parameters */ ParameterIndex(235), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [7] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(265), + /* parameters */ ParameterIndex(381), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [8] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(102), + /* parameters */ ParameterIndex(443), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [9] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [10] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(591), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(176), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [11] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(595), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(185), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [12] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(599), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [13] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(603), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(176), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [14] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(607), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(185), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [15] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(19), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [16] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(316), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(176), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [17] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(185), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [18] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(326), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [19] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(47), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(176), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [20] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(311), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(185), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [21] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(316), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [22] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(176), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [23] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(326), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(185), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [24] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(331), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [25] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(150), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [26] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(156), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [27] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [28] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(168), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [29] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(174), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [30] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(611), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [31] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(615), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [32] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(619), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 4, + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [33] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(623), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [34] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(627), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [35] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(411), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [36] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(416), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [37] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(336), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [38] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(426), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [39] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(659), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(366), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [40] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(180), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(359), + /* parameters */ ParameterIndex(423), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [41] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(631), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(75), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [42] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(359), + /* parameters */ ParameterIndex(425), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [43] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(639), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(27), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [44] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(204), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(359), + /* parameters */ ParameterIndex(427), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [45] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(372), + /* return_matcher_indices */ MatcherIndicesIndex(346), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [46] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(583), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* num_templates */ 2, + /* templates */ TemplateIndex(359), + /* parameters */ ParameterIndex(429), + /* return_matcher_indices */ MatcherIndicesIndex(346), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [47] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(184), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [48] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(296), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* num_templates */ 2, + /* templates */ TemplateIndex(359), + /* parameters */ ParameterIndex(431), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [49] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(703), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(80), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [50] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(516), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* num_templates */ 2, + /* templates */ TemplateIndex(359), + /* parameters */ ParameterIndex(433), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [51] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(663), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(375), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [52] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(667), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [53] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(435), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [54] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(675), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [55] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(679), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(437), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [56] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(436), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [57] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(441), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(439), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [58] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(446), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [59] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(451), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(441), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [60] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(456), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(381), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [61] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(436), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(361), + /* parameters */ ParameterIndex(519), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [62] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(441), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(361), + /* parameters */ ParameterIndex(520), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [63] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(446), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(361), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [64] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(451), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(361), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(346), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [65] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(456), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(363), + /* parameters */ ParameterIndex(519), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [66] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(210), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(363), + /* parameters */ ParameterIndex(520), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [67] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(216), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(363), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [68] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(222), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(363), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(346), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [69] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(228), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(361), + /* parameters */ ParameterIndex(523), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [70] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(234), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 2, + /* templates */ TemplateIndex(363), + /* parameters */ ParameterIndex(523), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [71] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(210), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(327), + /* return_matcher_indices */ MatcherIndicesIndex(324), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [72] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(216), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(500), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [73] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(222), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(501), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [74] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(228), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(393), + /* parameters */ ParameterIndex(502), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [75] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(234), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(341), + /* parameters */ ParameterIndex(319), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [76] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(461), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(274), + /* parameters */ ParameterIndex(503), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [77] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(466), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(343), + /* parameters */ ParameterIndex(504), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [78] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(471), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(349), + /* parameters */ ParameterIndex(319), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [79] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(476), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(351), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [80] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(481), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(385), + /* parameters */ ParameterIndex(500), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [81] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(461), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(506), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [82] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(466), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(353), + /* parameters */ ParameterIndex(504), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [83] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(471), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(343), + /* parameters */ ParameterIndex(507), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [84] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(476), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(353), + /* parameters */ ParameterIndex(507), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [85] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(481), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(355), + /* parameters */ ParameterIndex(319), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [86] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(683), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(508), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [87] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(687), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(393), + /* parameters */ ParameterIndex(509), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [88] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(691), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(357), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [89] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(695), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(394), + /* parameters */ ParameterIndex(510), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [90] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(699), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [91] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(486), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(307), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [92] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(491), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [93] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(496), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [94] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(501), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(408), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [95] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(506), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(411), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [96] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(414), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [97] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(493), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [98] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(495), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [99] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [100] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(703), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(381), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [101] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(516), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(383), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [102] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(385), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [103] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(244), - /* parameters */ ParameterIndex(869), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(387), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [104] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(247), - /* return_matcher_indices */ MatcherIndicesIndex(403), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(389), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [105] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(244), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(403), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(391), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(356), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [106] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(55), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(207), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [107] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(244), - /* parameters */ ParameterIndex(873), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [108] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(409), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(195), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [109] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(244), - /* parameters */ ParameterIndex(875), - /* return_matcher_indices */ MatcherIndicesIndex(409), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(19), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [110] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(564), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(99), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [111] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(244), - /* parameters */ ParameterIndex(877), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(50), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [112] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(272), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(199), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [113] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(244), - /* parameters */ ParameterIndex(879), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(119), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [114] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(56), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [115] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(881), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [116] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(187), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [117] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(883), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [118] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(84), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [119] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(885), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(215), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [120] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(409), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [121] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(887), - /* return_matcher_indices */ MatcherIndicesIndex(409), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(207), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [122] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(124), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [123] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(889), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(124), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [124] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(62), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [125] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(891), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(62), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [126] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(129), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [127] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* parameters */ ParameterIndex(129), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [128] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(893), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(211), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [129] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(134), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [130] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(895), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [131] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 1, + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [132] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(897), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 2, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [133] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 2, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [134] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(899), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* templates */ TemplateIndex(106), + /* parameters */ ParameterIndex(215), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [135] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 2, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [136] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(248), - /* parameters */ ParameterIndex(965), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* num_templates */ 3, + /* templates */ TemplateIndex(102), + /* parameters */ ParameterIndex(330), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [137] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(248), - /* parameters */ ParameterIndex(966), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 3, + /* templates */ TemplateIndex(102), + /* parameters */ ParameterIndex(333), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [138] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(248), - /* parameters */ ParameterIndex(967), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 4, + /* templates */ TemplateIndex(102), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [139] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(248), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(409), + /* num_templates */ 3, + /* templates */ TemplateIndex(102), + /* parameters */ ParameterIndex(336), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [140] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(250), - /* parameters */ ParameterIndex(965), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [141] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(250), - /* parameters */ ParameterIndex(966), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 3, + /* templates */ TemplateIndex(113), + /* parameters */ ParameterIndex(342), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [142] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(250), - /* parameters */ ParameterIndex(967), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 3, + /* templates */ TemplateIndex(113), + /* parameters */ ParameterIndex(345), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [143] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(250), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(409), + /* num_templates */ 4, + /* templates */ TemplateIndex(113), + /* parameters */ ParameterIndex(223), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [144] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(248), - /* parameters */ ParameterIndex(969), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* num_templates */ 3, + /* templates */ TemplateIndex(113), + /* parameters */ ParameterIndex(348), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [145] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(250), - /* parameters */ ParameterIndex(969), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(351), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [146] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(787), - /* return_matcher_indices */ MatcherIndicesIndex(403), + /* num_templates */ 3, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(354), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [147] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(169), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(357), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [148] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(169), - /* parameters */ ParameterIndex(829), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(227), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [149] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(719), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(360), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [150] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(169), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(363), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [151] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(835), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(300), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [152] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(838), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(303), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [153] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(723), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(306), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [154] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(841), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(309), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [155] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(172), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(312), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [156] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(117), - /* parameters */ ParameterIndex(847), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [157] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(19), - /* parameters */ ParameterIndex(727), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* templates */ TemplateIndex(318), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [158] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(158), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(13), + /* templates */ TemplateIndex(365), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [159] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(19), - /* parameters */ ParameterIndex(901), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(367), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [160] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(369), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [161] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(371), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [162] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(373), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [163] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [164] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(377), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [165] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* templates */ TemplateIndex(300), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [166] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(303), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [167] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(306), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [168] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(309), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [169] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(312), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [170] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [171] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* templates */ TemplateIndex(321), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [172] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(365), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [173] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(367), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [174] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(369), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [175] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(371), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [176] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(373), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [177] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [178] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(377), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [179] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_templates */ 2, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(74), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [180] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_templates */ 2, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(74), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [181] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 3, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(26), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [182] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_templates */ 3, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(26), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [183] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_templates */ 2, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(183), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [184] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(79), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [185] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [186] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(187), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [187] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [188] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(397), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(84), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [189] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(215), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [190] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(336), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [191] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(341), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(117), + /* parameters */ ParameterIndex(239), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [192] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(27), + /* parameters */ ParameterIndex(243), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [193] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(351), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(123), + /* parameters */ ParameterIndex(247), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [194] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(356), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(129), + /* parameters */ ParameterIndex(251), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [195] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(336), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(35), + /* parameters */ ParameterIndex(255), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [196] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(341), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(43), + /* parameters */ ParameterIndex(259), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [197] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 7, + /* templates */ TemplateIndex(75), + /* parameters */ ParameterIndex(384), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [198] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(351), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 9, + /* templates */ TemplateIndex(0), + /* parameters */ ParameterIndex(387), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [199] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(356), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 7, + /* templates */ TemplateIndex(82), + /* parameters */ ParameterIndex(390), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [200] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(90), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 7, + /* templates */ TemplateIndex(89), + /* parameters */ ParameterIndex(393), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [201] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(96), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 9, + /* templates */ TemplateIndex(9), + /* parameters */ ParameterIndex(396), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [202] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(102), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 9, + /* templates */ TemplateIndex(18), + /* parameters */ ParameterIndex(399), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [203] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(108), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 5, + /* templates */ TemplateIndex(136), + /* parameters */ ParameterIndex(149), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [204] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(114), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 7, + /* templates */ TemplateIndex(52), + /* parameters */ ParameterIndex(154), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [205] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(90), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 5, + /* templates */ TemplateIndex(142), + /* parameters */ ParameterIndex(159), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [206] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(96), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 5, + /* templates */ TemplateIndex(148), + /* parameters */ ParameterIndex(164), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [207] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(102), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 7, + /* templates */ TemplateIndex(60), + /* parameters */ ParameterIndex(169), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [208] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(108), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 7, + /* templates */ TemplateIndex(68), + /* parameters */ ParameterIndex(174), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [209] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(114), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(263), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [210] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(361), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(51), + /* parameters */ ParameterIndex(267), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [211] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(366), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(141), + /* parameters */ ParameterIndex(271), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [212] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(371), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(147), + /* parameters */ ParameterIndex(275), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [213] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(376), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(59), + /* parameters */ ParameterIndex(279), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [214] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(381), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(67), + /* parameters */ ParameterIndex(283), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [215] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(361), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [216] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(366), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [217] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(371), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [218] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(376), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [219] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(381), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(408), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [220] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(643), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(411), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [221] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(647), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(381), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [222] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(651), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(383), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [223] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(655), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(385), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [224] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(659), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(387), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [225] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(386), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(389), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [226] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(391), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(391), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [227] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(396), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(366), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [228] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(401), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(75), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [229] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(406), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(27), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [230] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(372), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [231] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(184), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [232] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(80), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [233] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [234] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [235] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [236] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [237] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [238] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [239] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [240] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(19), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [241] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(26), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(381), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [242] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(33), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(383), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [243] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(40), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(385), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [244] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(47), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(387), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [245] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(19), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(389), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [246] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(26), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(391), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(376), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [247] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(33), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [248] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(40), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [249] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(47), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(480), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [250] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(150), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [251] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(156), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(486), + /* return_matcher_indices */ MatcherIndicesIndex(225), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [252] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(485), + /* return_matcher_indices */ MatcherIndicesIndex(225), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [253] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(168), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(324), + /* parameters */ ParameterIndex(487), + /* return_matcher_indices */ MatcherIndicesIndex(307), + /* const_eval_fn */ ConstEvalFunctionIndex(89), }, { /* [254] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(174), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(324), + /* parameters */ ParameterIndex(489), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(90), }, { /* [255] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(150), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 4, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(491), + /* return_matcher_indices */ MatcherIndicesIndex(229), + /* const_eval_fn */ ConstEvalFunctionIndex(91), }, { /* [256] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(156), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(104), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [257] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(104), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [258] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(168), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(38), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [259] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(174), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(38), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [260] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(411), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(109), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [261] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(416), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(109), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [262] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(203), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [263] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(426), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(114), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -13491,8 +11248,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(431), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -13500,10 +11257,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(180), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -13511,32 +11268,32 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(186), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(19), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [267] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 7, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(192), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(19), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [268] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(198), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(50), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -13544,307 +11301,307 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(204), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(50), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [270] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(246), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(119), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [271] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(153), - /* parameters */ ParameterIndex(251), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(56), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [272] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(156), - /* parameters */ ParameterIndex(555), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(153), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [273] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(559), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(153), + /* parameters */ ParameterIndex(405), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [274] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(266), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(162), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [275] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(246), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(162), + /* parameters */ ParameterIndex(405), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [276] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(153), - /* parameters */ ParameterIndex(251), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [277] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(163), - /* parameters */ ParameterIndex(256), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(153), + /* parameters */ ParameterIndex(405), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [278] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(166), - /* parameters */ ParameterIndex(261), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [279] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(266), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(162), + /* parameters */ ParameterIndex(405), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [280] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(54), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(171), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [281] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(60), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(96), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [282] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(66), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(180), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [283] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(72), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(107), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [284] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(78), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(171), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [285] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(54), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 7, + /* templates */ TemplateIndex(96), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [286] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(60), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(180), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [287] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(66), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 7, + /* templates */ TemplateIndex(107), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(213), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [288] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(72), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(97), + /* parameters */ ParameterIndex(476), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [289] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(78), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(97), + /* parameters */ ParameterIndex(478), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [290] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(563), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(108), + /* parameters */ ParameterIndex(476), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [291] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(153), - /* parameters */ ParameterIndex(567), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(108), + /* parameters */ ParameterIndex(478), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [292] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(156), - /* parameters */ ParameterIndex(571), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(294), + /* parameters */ ParameterIndex(476), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [293] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(575), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(478), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [294] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(579), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(297), + /* parameters */ ParameterIndex(476), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [295] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(271), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(262), + /* parameters */ ParameterIndex(478), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [296] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(276), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -13852,10 +11609,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(281), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -13863,1166 +11620,1166 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(286), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [299] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(291), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [300] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [301] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(583), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(334), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [302] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(27), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [303] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(296), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(80), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [304] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(703), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [305] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(516), - /* return_matcher_indices */ MatcherIndicesIndex(395), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [306] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(185), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(361), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [307] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(188), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(363), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [308] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(191), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [309] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(194), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [310] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(197), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [311] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(200), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [312] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(203), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [313] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(252), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [314] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(254), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [315] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(256), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [316] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(258), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [317] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(260), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [318] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(262), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [319] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(206), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(105), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(264), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [320] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(209), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(400), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [321] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(212), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(530), + /* return_matcher_indices */ MatcherIndicesIndex(400), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [322] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(215), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(400), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [323] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(218), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(400), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [324] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(221), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(531), + /* return_matcher_indices */ MatcherIndicesIndex(400), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [325] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(224), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(532), + /* return_matcher_indices */ MatcherIndicesIndex(400), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [326] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(185), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(406), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [327] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(188), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(533), + /* return_matcher_indices */ MatcherIndicesIndex(406), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [328] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(191), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(406), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [329] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(194), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(406), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [330] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(197), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(534), + /* return_matcher_indices */ MatcherIndicesIndex(406), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [331] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(200), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(535), + /* return_matcher_indices */ MatcherIndicesIndex(406), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [332] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(227), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(412), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [333] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(252), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(536), + /* return_matcher_indices */ MatcherIndicesIndex(412), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [334] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 8, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(254), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(412), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [335] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(256), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(307), + /* return_matcher_indices */ MatcherIndicesIndex(412), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [336] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(258), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(537), + /* return_matcher_indices */ MatcherIndicesIndex(412), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [337] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(260), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(538), + /* return_matcher_indices */ MatcherIndicesIndex(412), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [338] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(262), - /* parameters */ ParameterIndex(974), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(418), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [339] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(206), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(539), + /* return_matcher_indices */ MatcherIndicesIndex(418), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [340] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(209), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(418), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [341] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(212), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(418), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [342] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(215), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(540), + /* return_matcher_indices */ MatcherIndicesIndex(418), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [343] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(218), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(541), + /* return_matcher_indices */ MatcherIndicesIndex(418), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [344] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(221), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(424), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [345] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(224), - /* parameters */ ParameterIndex(973), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(542), + /* return_matcher_indices */ MatcherIndicesIndex(424), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [346] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 9, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(424), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [347] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(247), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(424), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [348] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(55), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(543), + /* return_matcher_indices */ MatcherIndicesIndex(424), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [349] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(544), + /* return_matcher_indices */ MatcherIndicesIndex(424), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [350] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(564), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(430), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [351] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(272), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(545), + /* return_matcher_indices */ MatcherIndicesIndex(430), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [352] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 12, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(430), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [353] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(307), + /* return_matcher_indices */ MatcherIndicesIndex(430), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [354] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(546), + /* return_matcher_indices */ MatcherIndicesIndex(430), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [355] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(547), + /* return_matcher_indices */ MatcherIndicesIndex(430), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [356] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(436), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [357] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(246), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(548), + /* return_matcher_indices */ MatcherIndicesIndex(436), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [358] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 8, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(436), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [359] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(436), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [360] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(549), + /* return_matcher_indices */ MatcherIndicesIndex(436), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [361] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(550), + /* return_matcher_indices */ MatcherIndicesIndex(436), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [362] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(442), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [363] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(551), + /* return_matcher_indices */ MatcherIndicesIndex(442), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [364] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 12, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(442), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [365] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(442), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [366] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(552), + /* return_matcher_indices */ MatcherIndicesIndex(442), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [367] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(802), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(553), + /* return_matcher_indices */ MatcherIndicesIndex(442), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [368] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(805), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(448), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [369] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(711), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(554), + /* return_matcher_indices */ MatcherIndicesIndex(448), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [370] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(808), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 16, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(448), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [371] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(811), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(307), + /* return_matcher_indices */ MatcherIndicesIndex(448), + /* const_eval_fn */ ConstEvalFunctionIndex(114), }, { /* [372] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(814), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(555), + /* return_matcher_indices */ MatcherIndicesIndex(448), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [373] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(817), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(195), + /* parameters */ ParameterIndex(556), + /* return_matcher_indices */ MatcherIndicesIndex(448), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [374] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(715), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [375] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(820), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [376] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(823), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(480), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [377] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [378] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(484), + /* return_matcher_indices */ MatcherIndicesIndex(225), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [379] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(178), + /* templates */ TemplateIndex(254), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [380] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [381] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(856), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(480), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [382] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(859), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [383] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(862), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(484), + /* return_matcher_indices */ MatcherIndicesIndex(225), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [384] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(950), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(96), }, { /* [385] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(952), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(244), + /* const_eval_fn */ ConstEvalFunctionIndex(96), }, { /* [386] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(954), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(96), }, { /* [387] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(266), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(379), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(96), }, { /* [388] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(268), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(446), + /* return_matcher_indices */ MatcherIndicesIndex(68), + /* const_eval_fn */ ConstEvalFunctionIndex(96), }, { /* [389] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(270), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 5, + /* templates */ TemplateIndex(189), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(131), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [390] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(272), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 5, + /* templates */ TemplateIndex(194), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(131), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [391] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 5, + /* templates */ TemplateIndex(199), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(131), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [392] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* num_templates */ 5, + /* templates */ TemplateIndex(204), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(131), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [393] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 5, + /* templates */ TemplateIndex(209), + /* parameters */ ParameterIndex(402), + /* return_matcher_indices */ MatcherIndicesIndex(146), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [394] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 5, + /* templates */ TemplateIndex(214), + /* parameters */ ParameterIndex(402), + /* return_matcher_indices */ MatcherIndicesIndex(146), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [395] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* num_explicit_templates */ 0, + /* num_templates */ 5, + /* templates */ TemplateIndex(219), + /* parameters */ ParameterIndex(402), + /* return_matcher_indices */ MatcherIndicesIndex(146), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [396] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(856), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 5, + /* templates */ TemplateIndex(224), + /* parameters */ ParameterIndex(402), + /* return_matcher_indices */ MatcherIndicesIndex(146), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [397] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(859), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(92), }, { /* [398] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(266), - /* parameters */ ParameterIndex(978), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(92), }, { /* [399] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(268), - /* parameters */ ParameterIndex(978), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(480), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(92), }, { /* [400] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(270), - /* parameters */ ParameterIndex(978), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(92), }, { /* [401] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(272), - /* parameters */ ParameterIndex(978), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(93), }, { /* [402] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(978), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(93), }, { /* [403] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(480), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(93), }, { /* [404] */ @@ -15030,1506 +12787,1506 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(93), }, { /* [405] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(95), }, { /* [406] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(938), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 1, + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(244), + /* const_eval_fn */ ConstEvalFunctionIndex(95), }, { /* [407] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(943), - /* return_matcher_indices */ MatcherIndicesIndex(188), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 1, + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(95), }, { /* [408] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(942), - /* return_matcher_indices */ MatcherIndicesIndex(188), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 2, + /* templates */ TemplateIndex(379), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(95), }, { /* [409] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(944), - /* return_matcher_indices */ MatcherIndicesIndex(378), - /* const_eval_fn */ ConstEvalFunctionIndex(87), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(43), }, { /* [410] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(946), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(88), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(316), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(43), }, { /* [411] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(948), - /* return_matcher_indices */ MatcherIndicesIndex(192), - /* const_eval_fn */ ConstEvalFunctionIndex(89), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(43), }, { /* [412] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(320), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(63), }, { /* [413] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(312), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(63), }, { /* [414] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(344), + /* parameters */ ParameterIndex(323), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(64), }, { /* [415] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* num_explicit_templates */ 0, + /* num_templates */ 4, + /* templates */ TemplateIndex(253), + /* parameters */ ParameterIndex(470), + /* return_matcher_indices */ MatcherIndicesIndex(116), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [416] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(266), - /* parameters */ ParameterIndex(977), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(291), + /* parameters */ ParameterIndex(472), + /* return_matcher_indices */ MatcherIndicesIndex(161), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [417] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(268), - /* parameters */ ParameterIndex(977), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(291), + /* parameters */ ParameterIndex(474), + /* return_matcher_indices */ MatcherIndicesIndex(166), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [418] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(270), - /* parameters */ ParameterIndex(977), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(16), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(105), }, { /* [419] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(272), - /* parameters */ ParameterIndex(977), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(379), + /* parameters */ ParameterIndex(482), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(105), }, { /* [420] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(977), - /* return_matcher_indices */ MatcherIndicesIndex(100), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(446), + /* return_matcher_indices */ MatcherIndicesIndex(68), + /* const_eval_fn */ ConstEvalFunctionIndex(105), }, { /* [421] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(55), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(9), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [422] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(272), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(527), + /* return_matcher_indices */ MatcherIndicesIndex(9), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [423] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(395), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(9), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [424] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [425] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [426] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(396), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [427] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(248), - /* parameters */ ParameterIndex(967), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(264), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [428] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(250), - /* parameters */ ParameterIndex(967), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(512), + /* return_matcher_indices */ MatcherIndicesIndex(264), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [429] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(397), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(264), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [430] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(64), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [431] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(500), + /* return_matcher_indices */ MatcherIndicesIndex(64), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [432] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(398), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(64), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [433] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [434] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [435] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(399), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [436] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(0), }, { /* [437] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(0), }, { /* [438] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(1), }, { /* [439] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(1), }, { /* [440] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(2), }, { /* [441] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(2), }, { /* [442] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(3), }, { /* [443] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(3), }, { /* [444] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(4), }, { /* [445] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(4), }, { /* [446] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(5), }, { /* [447] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(5), }, { /* [448] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(6), }, { /* [449] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(6), }, { /* [450] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(7), }, { /* [451] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(7), }, { /* [452] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(787), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(8), }, { /* [453] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(0), - /* parameters */ ParameterIndex(731), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(8), }, { /* [454] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(0), - /* parameters */ ParameterIndex(735), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(9), }, { /* [455] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(6), - /* parameters */ ParameterIndex(739), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(9), }, { /* [456] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(743), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(11), }, { /* [457] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(6), - /* parameters */ ParameterIndex(747), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(11), }, { /* [458] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(751), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(12), }, { /* [459] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(1), - /* parameters */ ParameterIndex(521), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(12), }, { /* [460] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(1), - /* parameters */ ParameterIndex(526), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(13), }, { /* [461] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(531), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(13), }, { /* [462] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(13), - /* parameters */ ParameterIndex(536), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(14), }, { /* [463] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(541), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(14), }, { /* [464] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(13), - /* parameters */ ParameterIndex(546), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(15), }, { /* [465] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(15), }, { /* [466] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(980), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(16), }, { /* [467] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(16), }, { /* [468] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(17), }, { /* [469] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(981), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(17), }, { /* [470] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(982), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(19), }, { /* [471] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(477), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(19), }, { /* [472] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(983), - /* return_matcher_indices */ MatcherIndicesIndex(477), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(21), }, { /* [473] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(477), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(39), + /* const_eval_fn */ ConstEvalFunctionIndex(21), }, { /* [474] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(477), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(512), + /* return_matcher_indices */ MatcherIndicesIndex(264), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [475] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(984), - /* return_matcher_indices */ MatcherIndicesIndex(477), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(513), + /* return_matcher_indices */ MatcherIndicesIndex(262), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [476] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(985), - /* return_matcher_indices */ MatcherIndicesIndex(477), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(25), }, { /* [477] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(483), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(25), }, { /* [478] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(986), - /* return_matcher_indices */ MatcherIndicesIndex(483), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(26), }, { /* [479] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 8, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(483), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(26), }, { /* [480] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(483), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(16), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(27), }, { /* [481] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(483), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(180), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(27), }, { /* [482] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(483), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(29), }, { /* [483] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(51), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(29), }, { /* [484] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(989), - /* return_matcher_indices */ MatcherIndicesIndex(51), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(30), }, { /* [485] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(51), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(30), }, { /* [486] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(51), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(31), }, { /* [487] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(990), - /* return_matcher_indices */ MatcherIndicesIndex(51), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(31), }, { /* [488] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(991), - /* return_matcher_indices */ MatcherIndicesIndex(51), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(32), }, { /* [489] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(316), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(32), }, { /* [490] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(992), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(33), }, { /* [491] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 9, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(33), }, { /* [492] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(328), + /* const_eval_fn */ ConstEvalFunctionIndex(34), }, { /* [493] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(993), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(265), + /* const_eval_fn */ ConstEvalFunctionIndex(34), }, { /* [494] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(994), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(15), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(35), }, { /* [495] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(26), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(35), }, { /* [496] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(995), - /* return_matcher_indices */ MatcherIndicesIndex(26), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(36), }, { /* [497] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 12, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(26), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(36), }, { /* [498] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(26), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(278), + /* parameters */ ParameterIndex(417), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(37), }, { /* [499] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(996), - /* return_matcher_indices */ MatcherIndicesIndex(26), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(419), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(37), }, { /* [500] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(997), - /* return_matcher_indices */ MatcherIndicesIndex(26), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(38), }, { /* [501] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(491), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(39), + /* const_eval_fn */ ConstEvalFunctionIndex(38), }, { /* [502] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(998), - /* return_matcher_indices */ MatcherIndicesIndex(491), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(39), }, { /* [503] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 8, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(491), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(39), }, { /* [504] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(491), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(40), }, { /* [505] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(999), - /* return_matcher_indices */ MatcherIndicesIndex(491), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(40), }, { /* [506] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1000), - /* return_matcher_indices */ MatcherIndicesIndex(491), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(41), }, { /* [507] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(41), }, { /* [508] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1001), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(42), }, { /* [509] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 12, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(42), }, { /* [510] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(330), + /* const_eval_fn */ ConstEvalFunctionIndex(44), }, { /* [511] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1002), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(271), + /* const_eval_fn */ ConstEvalFunctionIndex(44), }, { /* [512] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1003), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(55), }, { /* [513] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(503), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(55), }, { /* [514] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1004), - /* return_matcher_indices */ MatcherIndicesIndex(503), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(512), + /* return_matcher_indices */ MatcherIndicesIndex(264), + /* const_eval_fn */ ConstEvalFunctionIndex(56), }, { /* [515] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 16, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(503), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(513), + /* return_matcher_indices */ MatcherIndicesIndex(262), + /* const_eval_fn */ ConstEvalFunctionIndex(56), }, { /* [516] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(503), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(57), }, { /* [517] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1005), - /* return_matcher_indices */ MatcherIndicesIndex(503), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(57), }, { /* [518] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1006), - /* return_matcher_indices */ MatcherIndicesIndex(503), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(60), }, { /* [519] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(84), + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(60), }, { /* [520] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(84), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(61), }, { /* [521] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(84), + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(61), }, { /* [522] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(938), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(84), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(62), }, { /* [523] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(188), - /* const_eval_fn */ ConstEvalFunctionIndex(84), + /* num_templates */ 2, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(62), }, { /* [524] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(32), + /* templates */ TemplateIndex(347), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(85), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(65), }, { /* [525] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(85), + /* templates */ TemplateIndex(346), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(65), }, { /* [526] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(85), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(66), }, { /* [527] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(938), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(85), + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(66), }, { /* [528] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(188), - /* const_eval_fn */ ConstEvalFunctionIndex(85), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(67), }, { /* [529] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(27), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(99), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(67), }, { /* [530] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(35), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(99), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(68), }, { /* [531] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(42), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(99), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(316), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(68), }, { /* [532] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(47), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(99), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(69), }, { /* [533] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(52), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(114), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(69), }, { /* [534] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(57), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(114), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(70), }, { /* [535] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(62), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(114), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(70), }, { /* [536] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(67), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(114), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(71), }, { /* [537] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(933), - /* return_matcher_indices */ MatcherIndicesIndex(176), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(71), }, { /* [538] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(935), - /* return_matcher_indices */ MatcherIndicesIndex(176), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(72), }, { /* [539] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(79), - /* parameters */ ParameterIndex(933), - /* return_matcher_indices */ MatcherIndicesIndex(176), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(72), }, { /* [540] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(79), - /* parameters */ ParameterIndex(935), - /* return_matcher_indices */ MatcherIndicesIndex(176), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(74), }, { /* [541] */ @@ -16537,538 +14294,538 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(73), - /* parameters */ ParameterIndex(971), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(74), }, { /* [542] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(175), - /* parameters */ ParameterIndex(972), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(82), }, { /* [543] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(80), - /* parameters */ ParameterIndex(971), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(421), + /* return_matcher_indices */ MatcherIndicesIndex(274), + /* const_eval_fn */ ConstEvalFunctionIndex(82), }, { /* [544] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(182), - /* parameters */ ParameterIndex(972), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* num_templates */ 1, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(375), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [545] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(90), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(381), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [546] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(90), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(334), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [547] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(90), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(327), + /* return_matcher_indices */ MatcherIndicesIndex(334), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [548] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(938), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(90), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(448), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [549] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(450), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [550] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(448), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [551] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(450), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [552] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(938), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(452), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [553] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(93), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(454), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [554] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(207), - /* const_eval_fn */ ConstEvalFunctionIndex(93), + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(456), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [555] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(93), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(458), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [556] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(264), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(93), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(460), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [557] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(94), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(462), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [558] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(207), - /* const_eval_fn */ ConstEvalFunctionIndex(94), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(448), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [559] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(94), + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(450), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [560] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(464), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [561] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(466), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [562] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(464), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [563] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(466), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [564] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [565] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(344), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [566] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(83), + }, + { + /* [567] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(99), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(244), + /* const_eval_fn */ ConstEvalFunctionIndex(83), + }, + { + /* [568] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(84), + }, + { + /* [569] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(379), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(84), + }, + { + /* [570] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(347), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(85), + }, + { + /* [571] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(347), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(85), + }, + { + /* [572] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(94), + }, + { + /* [573] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(264), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), + /* templates */ TemplateIndex(379), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(94), }, - { - /* [561] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(42), - }, - { - /* [562] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(42), - }, - { - /* [563] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(777), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(42), - }, - { - /* [564] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(780), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(62), - }, - { - /* [565] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(772), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(62), - }, - { - /* [566] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(177), - /* parameters */ ParameterIndex(783), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(63), - }, - { - /* [567] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(31), - /* parameters */ ParameterIndex(927), - /* return_matcher_indices */ MatcherIndicesIndex(84), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [568] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(39), - /* parameters */ ParameterIndex(929), - /* return_matcher_indices */ MatcherIndicesIndex(129), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [569] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(39), - /* parameters */ ParameterIndex(931), - /* return_matcher_indices */ MatcherIndicesIndex(134), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [570] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(10), - /* const_eval_fn */ ConstEvalFunctionIndex(105), - }, - { - /* [571] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(975), - /* return_matcher_indices */ MatcherIndicesIndex(10), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [572] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(276), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(10), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [573] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(105), - }, { /* [574] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(99), }, { /* [575] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(277), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 2, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(310), + /* const_eval_fn */ ConstEvalFunctionIndex(99), }, { /* [576] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* num_templates */ 1, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(100), }, { /* [577] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(958), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* num_templates */ 2, + /* templates */ TemplateIndex(345), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(310), + /* const_eval_fn */ ConstEvalFunctionIndex(100), }, { /* [578] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(278), + /* templates */ TemplateIndex(254), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(101), }, { /* [579] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(310), + /* const_eval_fn */ ConstEvalFunctionIndex(101), }, { /* [580] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(976), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(102), }, { /* [581] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(279), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(310), + /* const_eval_fn */ ConstEvalFunctionIndex(102), }, { /* [582] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(105), + /* num_templates */ 1, + /* templates */ TemplateIndex(254), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(103), }, { /* [583] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(310), + /* const_eval_fn */ ConstEvalFunctionIndex(103), }, { /* [584] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(280), + /* templates */ TemplateIndex(254), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(104), }, { /* [585] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(0), + /* num_templates */ 2, + /* templates */ TemplateIndex(337), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(310), + /* const_eval_fn */ ConstEvalFunctionIndex(104), }, { /* [586] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(0), + /* num_templates */ 1, + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(16), + /* return_matcher_indices */ MatcherIndicesIndex(57), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [587] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(1), + /* num_templates */ 2, + /* templates */ TemplateIndex(379), + /* parameters */ ParameterIndex(482), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [588] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(1), + /* num_templates */ 3, + /* templates */ TemplateIndex(271), + /* parameters */ ParameterIndex(499), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [589] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(2), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(326), + /* const_eval_fn */ ConstEvalFunctionIndex(18), }, { /* [590] */ @@ -17076,1894 +14833,277 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(2), + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(511), + /* return_matcher_indices */ MatcherIndicesIndex(39), + /* const_eval_fn */ ConstEvalFunctionIndex(20), }, { /* [591] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(3), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(39), + /* const_eval_fn */ ConstEvalFunctionIndex(22), }, { /* [592] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(9), + /* const_eval_fn */ ConstEvalFunctionIndex(23), }, { /* [593] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(4), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(24), }, { /* [594] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(4), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(316), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(28), }, { /* [595] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(5), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(45), }, { /* [596] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(5), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(514), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(46), }, { /* [597] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(6), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(514), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(47), }, { /* [598] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(6), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(514), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(48), }, { /* [599] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(7), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(515), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(49), }, { /* [600] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(7), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(515), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(50), }, { /* [601] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(8), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(51), }, { /* [602] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(8), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(52), }, { /* [603] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(9), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(53), }, { /* [604] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(9), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(54), }, { /* [605] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), + /* num_templates */ 2, + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(58), }, { /* [606] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(10), + /* templates */ TemplateIndex(277), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(241), + /* const_eval_fn */ ConstEvalFunctionIndex(59), }, { /* [607] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(11), + /* num_templates */ 3, + /* templates */ TemplateIndex(280), + /* parameters */ ParameterIndex(518), + /* return_matcher_indices */ MatcherIndicesIndex(205), + /* const_eval_fn */ ConstEvalFunctionIndex(73), }, { /* [608] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(11), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(332), + /* const_eval_fn */ ConstEvalFunctionIndex(75), }, { /* [609] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(12), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(332), + /* const_eval_fn */ ConstEvalFunctionIndex(76), }, { /* [610] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(12), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(332), + /* const_eval_fn */ ConstEvalFunctionIndex(77), }, { /* [611] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(13), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(334), + /* const_eval_fn */ ConstEvalFunctionIndex(78), }, { /* [612] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(13), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(334), + /* const_eval_fn */ ConstEvalFunctionIndex(79), }, { /* [613] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(14), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(336), + /* const_eval_fn */ ConstEvalFunctionIndex(80), }, { /* [614] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(14), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(338), + /* const_eval_fn */ ConstEvalFunctionIndex(81), }, { /* [615] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(15), - }, - { - /* [616] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(15), - }, - { - /* [617] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(16), - }, - { - /* [618] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(16), - }, - { - /* [619] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(18), - }, - { - /* [620] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(18), - }, - { - /* [621] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(20), - }, - { - /* [622] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(24), - /* const_eval_fn */ ConstEvalFunctionIndex(20), - }, - { - /* [623] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(958), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [624] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(959), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [625] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(24), - }, - { - /* [626] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(24), - }, - { - /* [627] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(25), - }, - { - /* [628] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(25), - }, - { - /* [629] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(16), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(26), - }, - { - /* [630] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(552), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(26), - }, - { - /* [631] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(28), - }, - { - /* [632] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(28), - }, - { - /* [633] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(29), - }, - { - /* [634] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(29), - }, - { - /* [635] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(30), - }, - { - /* [636] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(30), - }, - { - /* [637] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(31), - }, - { - /* [638] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(31), - }, - { - /* [639] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(32), - }, - { - /* [640] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(32), - }, - { - /* [641] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(389), - /* const_eval_fn */ ConstEvalFunctionIndex(33), - }, - { - /* [642] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(216), - /* const_eval_fn */ ConstEvalFunctionIndex(33), - }, - { - /* [643] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(15), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(34), - }, - { - /* [644] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(34), - }, - { - /* [645] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(35), - }, - { - /* [646] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(35), - }, - { - /* [647] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(865), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(36), - }, - { - /* [648] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(867), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(36), - }, - { - /* [649] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(37), - }, - { - /* [650] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(24), - /* const_eval_fn */ ConstEvalFunctionIndex(37), - }, - { - /* [651] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(38), - }, - { - /* [652] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(38), - }, - { - /* [653] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(39), - }, - { - /* [654] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(39), - }, - { - /* [655] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(40), - }, - { - /* [656] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(40), - }, - { - /* [657] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(41), - }, - { - /* [658] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(41), - }, - { - /* [659] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(391), - /* const_eval_fn */ ConstEvalFunctionIndex(43), - }, - { - /* [660] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(222), - /* const_eval_fn */ ConstEvalFunctionIndex(43), - }, - { - /* [661] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(54), - }, - { - /* [662] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(54), - }, - { - /* [663] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(958), - /* return_matcher_indices */ MatcherIndicesIndex(13), - /* const_eval_fn */ ConstEvalFunctionIndex(55), - }, - { - /* [664] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(959), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(55), - }, - { - /* [665] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(56), - }, - { - /* [666] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(56), - }, - { - /* [667] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(59), - }, - { - /* [668] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(59), - }, - { - /* [669] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(60), - }, - { - /* [670] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(60), - }, - { - /* [671] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(61), - }, - { - /* [672] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(61), - }, - { - /* [673] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(180), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(64), - }, - { - /* [674] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(179), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(64), - }, - { - /* [675] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(65), - }, - { - /* [676] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(65), - }, - { - /* [677] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(66), - }, - { - /* [678] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(66), - }, - { - /* [679] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(67), - }, - { - /* [680] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(67), - }, - { - /* [681] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(68), - }, - { - /* [682] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(68), - }, - { - /* [683] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(69), - }, - { - /* [684] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(69), - }, - { - /* [685] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(70), - }, - { - /* [686] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(70), - }, - { - /* [687] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(71), - }, - { - /* [688] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(71), - }, - { - /* [689] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(73), - }, - { - /* [690] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(73), - }, - { - /* [691] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [692] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [693] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(905), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [694] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(907), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [695] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(905), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [696] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(907), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [697] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(909), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [698] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(911), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [699] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(913), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [700] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(915), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [701] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(917), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [702] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(919), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [703] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(905), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [704] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(907), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [705] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(921), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [706] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(923), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [707] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(921), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [708] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(923), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [709] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [710] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(177), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [711] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(81), - }, - { - /* [712] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(207), - /* const_eval_fn */ ConstEvalFunctionIndex(81), - }, - { - /* [713] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(82), - }, - { - /* [714] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(264), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(82), - }, - { - /* [715] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(180), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(83), - }, - { - /* [716] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(180), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(83), - }, - { - /* [717] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(92), - }, - { - /* [718] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(264), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(92), - }, - { - /* [719] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(97), - }, - { - /* [720] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(381), - /* const_eval_fn */ ConstEvalFunctionIndex(97), - }, - { - /* [721] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(98), - }, - { - /* [722] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(381), - /* const_eval_fn */ ConstEvalFunctionIndex(98), - }, - { - /* [723] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(99), - }, - { - /* [724] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(381), - /* const_eval_fn */ ConstEvalFunctionIndex(99), - }, - { - /* [725] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(100), - }, - { - /* [726] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(381), - /* const_eval_fn */ ConstEvalFunctionIndex(100), - }, - { - /* [727] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(101), - }, - { - /* [728] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(381), - /* const_eval_fn */ ConstEvalFunctionIndex(101), - }, - { - /* [729] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(102), - }, - { - /* [730] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(381), - /* const_eval_fn */ ConstEvalFunctionIndex(102), - }, - { - /* [731] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(16), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(103), - }, - { - /* [732] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(264), - /* parameters */ ParameterIndex(939), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(103), - }, - { - /* [733] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(16), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(104), - }, - { - /* [734] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(264), - /* parameters */ ParameterIndex(939), - /* return_matcher_indices */ MatcherIndicesIndex(210), - /* const_eval_fn */ ConstEvalFunctionIndex(104), - }, - { - /* [735] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(242), - /* parameters */ ParameterIndex(956), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [736] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(387), - /* const_eval_fn */ ConstEvalFunctionIndex(17), - }, - { - /* [737] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(957), - /* return_matcher_indices */ MatcherIndicesIndex(24), - /* const_eval_fn */ ConstEvalFunctionIndex(19), - }, - { - /* [738] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(83), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(24), - /* const_eval_fn */ ConstEvalFunctionIndex(21), - }, - { - /* [739] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(10), - /* const_eval_fn */ ConstEvalFunctionIndex(22), - }, - { - /* [740] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(23), - }, - { - /* [741] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(27), - }, - { - /* [742] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(44), - }, - { - /* [743] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(960), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(45), - }, - { - /* [744] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(960), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(46), - }, - { - /* [745] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(960), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(47), - }, - { - /* [746] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(961), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(48), - }, - { - /* [747] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(961), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(49), - }, - { - /* [748] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(962), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(50), - }, - { - /* [749] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(963), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(51), - }, - { - /* [750] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(962), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(52), - }, - { - /* [751] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(963), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(53), - }, - { - /* [752] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(57), - }, - { - /* [753] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(777), - /* return_matcher_indices */ MatcherIndicesIndex(204), - /* const_eval_fn */ ConstEvalFunctionIndex(58), - }, - { - /* [754] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(148), - /* parameters */ ParameterIndex(964), - /* return_matcher_indices */ MatcherIndicesIndex(168), - /* const_eval_fn */ ConstEvalFunctionIndex(72), - }, - { - /* [755] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(393), - /* const_eval_fn */ ConstEvalFunctionIndex(74), - }, - { - /* [756] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(393), - /* const_eval_fn */ ConstEvalFunctionIndex(75), - }, - { - /* [757] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(393), - /* const_eval_fn */ ConstEvalFunctionIndex(76), - }, - { - /* [758] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(77), - }, - { - /* [759] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(395), - /* const_eval_fn */ ConstEvalFunctionIndex(78), - }, - { - /* [760] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(397), - /* const_eval_fn */ ConstEvalFunctionIndex(79), - }, - { - /* [761] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(399), - /* const_eval_fn */ ConstEvalFunctionIndex(80), - }, - { - /* [762] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 0, /* num_explicit_templates */ 0, @@ -18974,159 +15114,181 @@ constexpr OverloadInfo kOverloads[] = { /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [763] */ + /* [616] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(970), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(524), + /* return_matcher_indices */ MatcherIndicesIndex(356), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [764] */ + /* [617] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(86), + /* templates */ TemplateIndex(339), /* parameters */ ParameterIndex(0), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [765] */ + /* [618] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(86), + /* templates */ TemplateIndex(339), /* parameters */ ParameterIndex(0), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [766] */ + /* [619] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(86), + /* templates */ TemplateIndex(339), /* parameters */ ParameterIndex(0), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(57), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [767] */ + /* [620] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(86), + /* templates */ TemplateIndex(339), /* parameters */ ParameterIndex(0), - /* return_matcher_indices */ MatcherIndicesIndex(453), + /* return_matcher_indices */ MatcherIndicesIndex(382), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [768] */ + /* [621] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(903), + /* parameters */ ParameterIndex(445), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [769] */ + /* [622] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(399), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(338), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [770] */ + /* [623] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 0, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [771] */ + /* [624] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [772] */ + /* [625] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(95), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(97), }, { - /* [773] */ + /* [626] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(209), - /* const_eval_fn */ ConstEvalFunctionIndex(96), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(137), + /* const_eval_fn */ ConstEvalFunctionIndex(98), }, { - /* [774] */ + /* [627] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 0, /* num_explicit_templates */ 3, /* num_templates */ 3, - /* templates */ TemplateIndex(233), + /* templates */ TemplateIndex(327), /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(149), + /* return_matcher_indices */ MatcherIndicesIndex(186), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [775] */ + /* [628] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 0, /* num_explicit_templates */ 3, /* num_templates */ 3, - /* templates */ TemplateIndex(236), + /* templates */ TemplateIndex(330), /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(154), + /* return_matcher_indices */ MatcherIndicesIndex(191), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [776] */ + /* [629] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 0, /* num_explicit_templates */ 3, /* num_templates */ 3, - /* templates */ TemplateIndex(239), + /* templates */ TemplateIndex(333), /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(159), + /* return_matcher_indices */ MatcherIndicesIndex(196), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, + { + /* [630] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(400), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(9), + /* const_eval_fn */ ConstEvalFunctionIndex(109), + }, + { + /* [631] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(68), + /* const_eval_fn */ ConstEvalFunctionIndex(109), + }, }; static_assert(OverloadIndex::CanIndex(kOverloads), @@ -19138,626 +15300,656 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn abs[T : fiu32_f16](T) -> T */ /* fn abs[N : num, T : fiu32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(585), + /* overloads */ OverloadIndex(436), }, { /* [1] */ /* fn acos[T : f32_f16](@test_value(0.96891242171) T) -> T */ /* fn acos[N : num, T : f32_f16](@test_value(0.96891242171) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(587), + /* overloads */ OverloadIndex(438), }, { /* [2] */ /* fn acosh[T : f32_f16](@test_value(1.5430806348) T) -> T */ /* fn acosh[N : num, T : f32_f16](@test_value(1.5430806348) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(589), + /* overloads */ OverloadIndex(440), }, { /* [3] */ /* fn all(bool) -> bool */ /* fn all[N : num](vec) -> bool */ /* num overloads */ 2, - /* overloads */ OverloadIndex(591), + /* overloads */ OverloadIndex(442), }, { /* [4] */ /* fn any(bool) -> bool */ /* fn any[N : num](vec) -> bool */ /* num overloads */ 2, - /* overloads */ OverloadIndex(593), + /* overloads */ OverloadIndex(444), }, { /* [5] */ - /* fn arrayLength[T, A : access](ptr, A>) -> u32 */ + /* fn arrayLength[T, AS : workgroup_uniform_storage, A : access](ptr, A>) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(735), + /* overloads */ OverloadIndex(588), }, { /* [6] */ /* fn asin[T : f32_f16](@test_value(0.479425538604) T) -> T */ /* fn asin[N : num, T : f32_f16](@test_value(0.479425538604) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(595), + /* overloads */ OverloadIndex(446), }, { /* [7] */ /* fn asinh[T : f32_f16](T) -> T */ /* fn asinh[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(597), + /* overloads */ OverloadIndex(448), }, { /* [8] */ /* fn atan[T : f32_f16](T) -> T */ /* fn atan[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(599), + /* overloads */ OverloadIndex(450), }, { /* [9] */ /* fn atan2[T : f32_f16](T, T) -> T */ /* fn atan2[T : f32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(601), + /* overloads */ OverloadIndex(452), }, { /* [10] */ /* fn atanh[T : f32_f16](@test_value(0.5) T) -> T */ /* fn atanh[N : num, T : f32_f16](@test_value(0.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(603), + /* overloads */ OverloadIndex(454), }, { /* [11] */ - /* fn ceil[T : f32_f16](@test_value(1.5) T) -> T */ - /* fn ceil[N : num, T : f32_f16](@test_value(1.5) vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(605), + /* fn bitcast(f16) -> T */ + /* fn bitcast(vec2) -> T */ + /* fn bitcast>(vec4) -> T */ + /* fn bitcast[U : fiu32](U) -> T */ + /* fn bitcast>[N : num, U : fiu32](vec) -> T */ + /* fn bitcast>[N : num](vec) -> T */ + /* fn bitcast>[S : fiu32](S) -> T */ + /* fn bitcast>[S : fiu32](vec2) -> T */ + /* fn bitcast(f16) -> T */ + /* fn bitcast(u16) -> T */ + /* fn bitcast>[N : num](vec) -> T */ + /* fn bitcast>[N : num](vec) -> T */ + /* fn bitcast>[N : num](vec) -> T */ + /* fn bitcast>[S : fiu32](S) -> T */ + /* fn bitcast(vec2) -> T */ + /* fn bitcast>(vec4) -> T */ + /* fn bitcast>[S : fiu32](vec2) -> T */ + /* fn bitcast(vec2) -> T */ + /* num overloads */ 18, + /* overloads */ OverloadIndex(72), }, { /* [12] */ - /* fn clamp[T : fiu32_f16](T, T, T) -> T */ - /* fn clamp[T : fiu32_f16, N : num](vec, vec, vec) -> vec */ + /* fn ceil[T : f32_f16](@test_value(1.5) T) -> T */ + /* fn ceil[N : num, T : f32_f16](@test_value(1.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(607), + /* overloads */ OverloadIndex(456), }, { /* [13] */ - /* fn cos[T : f32_f16](@test_value(0) T) -> T */ - /* fn cos[N : num, T : f32_f16](@test_value(0) vec) -> vec */ + /* fn clamp[T : fiu32_f16](T, T, T) -> T */ + /* fn clamp[T : fiu32_f16, N : num](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(609), + /* overloads */ OverloadIndex(458), }, { /* [14] */ - /* fn cosh[T : f32_f16](@test_value(0) T) -> T */ - /* fn cosh[N : num, T : f32_f16](@test_value(0) vec) -> vec */ + /* fn cos[T : f32_f16](@test_value(0) T) -> T */ + /* fn cos[N : num, T : f32_f16](@test_value(0) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(611), + /* overloads */ OverloadIndex(460), }, { /* [15] */ - /* fn countLeadingZeros[T : iu32](T) -> T */ - /* fn countLeadingZeros[N : num, T : iu32](vec) -> vec */ + /* fn cosh[T : f32_f16](@test_value(0) T) -> T */ + /* fn cosh[N : num, T : f32_f16](@test_value(0) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(613), + /* overloads */ OverloadIndex(462), }, { /* [16] */ - /* fn countOneBits[T : iu32](T) -> T */ - /* fn countOneBits[N : num, T : iu32](vec) -> vec */ + /* fn countLeadingZeros[T : iu32](T) -> T */ + /* fn countLeadingZeros[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(615), + /* overloads */ OverloadIndex(464), }, { /* [17] */ - /* fn countTrailingZeros[T : iu32](T) -> T */ - /* fn countTrailingZeros[N : num, T : iu32](vec) -> vec */ + /* fn countOneBits[T : iu32](T) -> T */ + /* fn countOneBits[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(617), + /* overloads */ OverloadIndex(466), }, { /* [18] */ - /* fn cross[T : f32_f16](vec3, vec3) -> vec3 */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(736), + /* fn countTrailingZeros[T : iu32](T) -> T */ + /* fn countTrailingZeros[N : num, T : iu32](vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(468), }, { /* [19] */ - /* fn degrees[T : f32_f16](T) -> T */ - /* fn degrees[N : num, T : f32_f16](vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(619), + /* fn cross[T : f32_f16](vec3, vec3) -> vec3 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(589), }, { /* [20] */ - /* fn determinant[N : num, T : f32_f16](mat) -> T */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(737), + /* fn degrees[T : f32_f16](T) -> T */ + /* fn degrees[N : num, T : f32_f16](vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(470), }, { /* [21] */ - /* fn distance[T : f32_f16](T, T) -> T */ - /* fn distance[N : num, T : f32_f16](vec, vec) -> T */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(621), + /* fn determinant[N : num, T : f32_f16](mat) -> T */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(590), }, { /* [22] */ - /* fn dot[N : num, T : fiu32_f16](vec, vec) -> T */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(738), + /* fn distance[T : f32_f16](T, T) -> T */ + /* fn distance[N : num, T : f32_f16](vec, vec) -> T */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(472), }, { /* [23] */ - /* fn dot4I8Packed(u32, u32) -> i32 */ + /* fn dot[N : num, T : fiu32_f16](vec, vec) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(739), + /* overloads */ OverloadIndex(591), }, { /* [24] */ - /* fn dot4U8Packed(u32, u32) -> u32 */ + /* fn dot4I8Packed(u32, u32) -> i32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(740), + /* overloads */ OverloadIndex(592), }, { /* [25] */ - /* fn dpdx(f32) -> f32 */ - /* fn dpdx[N : num](vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* fn dot4U8Packed(u32, u32) -> u32 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(593), }, { /* [26] */ - /* fn dpdxCoarse(f32) -> f32 */ - /* fn dpdxCoarse[N : num](vec) -> vec */ + /* fn dpdx(f32) -> f32 */ + /* fn dpdx[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [27] */ - /* fn dpdxFine(f32) -> f32 */ - /* fn dpdxFine[N : num](vec) -> vec */ + /* fn dpdxCoarse(f32) -> f32 */ + /* fn dpdxCoarse[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [28] */ - /* fn dpdy(f32) -> f32 */ - /* fn dpdy[N : num](vec) -> vec */ + /* fn dpdxFine(f32) -> f32 */ + /* fn dpdxFine[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [29] */ - /* fn dpdyCoarse(f32) -> f32 */ - /* fn dpdyCoarse[N : num](vec) -> vec */ + /* fn dpdy(f32) -> f32 */ + /* fn dpdy[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [30] */ - /* fn dpdyFine(f32) -> f32 */ - /* fn dpdyFine[N : num](vec) -> vec */ + /* fn dpdyCoarse(f32) -> f32 */ + /* fn dpdyCoarse[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [31] */ - /* fn exp[T : f32_f16](T) -> T */ - /* fn exp[N : num, T : f32_f16](vec) -> vec */ + /* fn dpdyFine(f32) -> f32 */ + /* fn dpdyFine[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(625), + /* overloads */ OverloadIndex(474), }, { /* [32] */ - /* fn exp2[T : f32_f16](T) -> T */ - /* fn exp2[N : num, T : f32_f16](vec) -> vec */ + /* fn exp[T : f32_f16](T) -> T */ + /* fn exp[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(627), + /* overloads */ OverloadIndex(476), }, { /* [33] */ - /* fn extractBits[T : iu32](T, u32, u32) -> T */ - /* fn extractBits[N : num, T : iu32](vec, u32, u32) -> vec */ + /* fn exp2[T : f32_f16](T) -> T */ + /* fn exp2[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(629), + /* overloads */ OverloadIndex(478), }, { /* [34] */ - /* fn faceForward[N : num, T : f32_f16](vec, vec, vec) -> vec */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(741), + /* fn extractBits[T : iu32](T, u32, u32) -> T */ + /* fn extractBits[N : num, T : iu32](vec, u32, u32) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(480), }, { /* [35] */ - /* fn firstLeadingBit[T : iu32](T) -> T */ - /* fn firstLeadingBit[N : num, T : iu32](vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(631), + /* fn faceForward[N : num, T : f32_f16](vec, vec, vec) -> vec */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(594), }, { /* [36] */ - /* fn firstTrailingBit[T : iu32](T) -> T */ - /* fn firstTrailingBit[N : num, T : iu32](vec) -> vec */ + /* fn firstLeadingBit[T : iu32](T) -> T */ + /* fn firstLeadingBit[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(633), + /* overloads */ OverloadIndex(482), }, { /* [37] */ - /* fn floor[T : f32_f16](@test_value(1.5) T) -> T */ - /* fn floor[N : num, T : f32_f16](@test_value(1.5) vec) -> vec */ + /* fn firstTrailingBit[T : iu32](T) -> T */ + /* fn firstTrailingBit[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(635), + /* overloads */ OverloadIndex(484), }, { /* [38] */ - /* fn fma[T : f32_f16](T, T, T) -> T */ - /* fn fma[N : num, T : f32_f16](vec, vec, vec) -> vec */ + /* fn floor[T : f32_f16](@test_value(1.5) T) -> T */ + /* fn floor[N : num, T : f32_f16](@test_value(1.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(637), + /* overloads */ OverloadIndex(486), }, { /* [39] */ - /* fn fract[T : f32_f16](@test_value(1.25) T) -> T */ - /* fn fract[N : num, T : f32_f16](@test_value(1.25) vec) -> vec */ + /* fn fma[T : f32_f16](T, T, T) -> T */ + /* fn fma[N : num, T : f32_f16](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(639), + /* overloads */ OverloadIndex(488), }, { /* [40] */ - /* fn frexp[T : f32_f16](T) -> __frexp_result */ - /* fn frexp[N : num, T : f32_f16](vec) -> __frexp_result_vec */ + /* fn fract[T : f32_f16](@test_value(1.25) T) -> T */ + /* fn fract[N : num, T : f32_f16](@test_value(1.25) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(641), + /* overloads */ OverloadIndex(490), }, { /* [41] */ - /* fn fwidth(f32) -> f32 */ - /* fn fwidth[N : num](vec) -> vec */ + /* fn frexp[T : f32_f16](T) -> __frexp_result */ + /* fn frexp[N : num, T : f32_f16](vec) -> __frexp_result_vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(492), }, { /* [42] */ - /* fn fwidthCoarse(f32) -> f32 */ - /* fn fwidthCoarse[N : num](vec) -> vec */ + /* fn fwidth(f32) -> f32 */ + /* fn fwidth[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [43] */ - /* fn fwidthFine(f32) -> f32 */ - /* fn fwidthFine[N : num](vec) -> vec */ + /* fn fwidthCoarse(f32) -> f32 */ + /* fn fwidthCoarse[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(623), + /* overloads */ OverloadIndex(474), }, { /* [44] */ - /* fn insertBits[T : iu32](T, T, u32, u32) -> T */ - /* fn insertBits[N : num, T : iu32](vec, vec, u32, u32) -> vec */ + /* fn fwidthFine(f32) -> f32 */ + /* fn fwidthFine[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(643), + /* overloads */ OverloadIndex(474), }, { /* [45] */ - /* fn inverseSqrt[T : f32_f16](T) -> T */ - /* fn inverseSqrt[N : num, T : f32_f16](vec) -> vec */ + /* fn insertBits[T : iu32](T, T, u32, u32) -> T */ + /* fn insertBits[N : num, T : iu32](vec, vec, u32, u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(645), + /* overloads */ OverloadIndex(494), }, { /* [46] */ - /* fn ldexp[T : f32_f16, U : i32](T, U) -> T */ - /* fn ldexp[N : num, T : f32_f16, U : i32](vec, vec) -> vec */ + /* fn inverseSqrt[T : f32_f16](T) -> T */ + /* fn inverseSqrt[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(647), + /* overloads */ OverloadIndex(496), }, { /* [47] */ - /* fn length[T : f32_f16](@test_value(0) T) -> T */ - /* fn length[N : num, T : f32_f16](@test_value(0) vec) -> T */ + /* fn ldexp[T : f32_f16, U : i32](T, U) -> T */ + /* fn ldexp[N : num, T : f32_f16, U : i32](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(649), + /* overloads */ OverloadIndex(498), }, { /* [48] */ - /* fn log[T : f32_f16](T) -> T */ - /* fn log[N : num, T : f32_f16](vec) -> vec */ + /* fn length[T : f32_f16](@test_value(0) T) -> T */ + /* fn length[N : num, T : f32_f16](@test_value(0) vec) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(651), + /* overloads */ OverloadIndex(500), }, { /* [49] */ - /* fn log2[T : f32_f16](T) -> T */ - /* fn log2[N : num, T : f32_f16](vec) -> vec */ + /* fn log[T : f32_f16](T) -> T */ + /* fn log[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(653), + /* overloads */ OverloadIndex(502), }, { /* [50] */ - /* fn max[T : fiu32_f16](T, T) -> T */ - /* fn max[N : num, T : fiu32_f16](vec, vec) -> vec */ + /* fn log2[T : f32_f16](T) -> T */ + /* fn log2[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(655), + /* overloads */ OverloadIndex(504), }, { /* [51] */ - /* fn min[T : fiu32_f16](T, T) -> T */ - /* fn min[N : num, T : fiu32_f16](vec, vec) -> vec */ + /* fn max[T : fiu32_f16](T, T) -> T */ + /* fn max[N : num, T : fiu32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(657), + /* overloads */ OverloadIndex(506), }, { /* [52] */ + /* fn min[T : fiu32_f16](T, T) -> T */ + /* fn min[N : num, T : fiu32_f16](vec, vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(508), + }, + { + /* [53] */ /* fn mix[T : f32_f16](T, T, T) -> T */ /* fn mix[N : num, T : f32_f16](vec, vec, vec) -> vec */ /* fn mix[N : num, T : f32_f16](vec, vec, T) -> vec */ /* num overloads */ 3, - /* overloads */ OverloadIndex(561), - }, - { - /* [53] */ - /* fn modf[T : f32_f16](@test_value(-1.5) T) -> __modf_result */ - /* fn modf[N : num, T : f32_f16](@test_value(-1.5) vec) -> __modf_result_vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(659), + /* overloads */ OverloadIndex(409), }, { /* [54] */ - /* fn normalize[N : num, T : f32_f16](vec) -> vec */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(742), + /* fn modf[T : f32_f16](@test_value(-1.5) T) -> __modf_result */ + /* fn modf[N : num, T : f32_f16](@test_value(-1.5) vec) -> __modf_result_vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(510), }, { /* [55] */ - /* fn pack2x16float(vec2) -> u32 */ + /* fn normalize[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(743), + /* overloads */ OverloadIndex(595), }, { /* [56] */ - /* fn pack2x16snorm(vec2) -> u32 */ + /* fn pack2x16float(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(744), + /* overloads */ OverloadIndex(596), }, { /* [57] */ - /* fn pack2x16unorm(vec2) -> u32 */ + /* fn pack2x16snorm(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(745), + /* overloads */ OverloadIndex(597), }, { /* [58] */ - /* fn pack4x8snorm(vec4) -> u32 */ + /* fn pack2x16unorm(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(746), + /* overloads */ OverloadIndex(598), }, { /* [59] */ - /* fn pack4x8unorm(vec4) -> u32 */ + /* fn pack4x8snorm(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(747), + /* overloads */ OverloadIndex(599), }, { /* [60] */ - /* fn pack4xI8(vec4) -> u32 */ + /* fn pack4x8unorm(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(748), + /* overloads */ OverloadIndex(600), }, { /* [61] */ - /* fn pack4xU8(vec4) -> u32 */ + /* fn pack4xI8(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(749), + /* overloads */ OverloadIndex(601), }, { /* [62] */ - /* fn pack4xI8Clamp(vec4) -> u32 */ + /* fn pack4xU8(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(750), + /* overloads */ OverloadIndex(602), }, { /* [63] */ - /* fn pack4xU8Clamp(vec4) -> u32 */ + /* fn pack4xI8Clamp(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(751), + /* overloads */ OverloadIndex(603), }, { /* [64] */ - /* fn pow[T : f32_f16](T, T) -> T */ - /* fn pow[N : num, T : f32_f16](vec, vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(661), + /* fn pack4xU8Clamp(vec4) -> u32 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(604), }, { /* [65] */ - /* fn quantizeToF16(f32) -> f32 */ - /* fn quantizeToF16[N : num](vec) -> vec */ + /* fn pow[T : f32_f16](T, T) -> T */ + /* fn pow[N : num, T : f32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(663), + /* overloads */ OverloadIndex(512), }, { /* [66] */ - /* fn radians[T : f32_f16](T) -> T */ - /* fn radians[N : num, T : f32_f16](vec) -> vec */ + /* fn quantizeToF16(f32) -> f32 */ + /* fn quantizeToF16[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(665), + /* overloads */ OverloadIndex(514), }, { /* [67] */ - /* fn reflect[N : num, T : f32_f16](vec, vec) -> vec */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(752), + /* fn radians[T : f32_f16](T) -> T */ + /* fn radians[N : num, T : f32_f16](vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(516), }, { /* [68] */ - /* fn refract[N : num, T : f32_f16](vec, vec, T) -> vec */ + /* fn reflect[N : num, T : f32_f16](vec, vec) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(753), + /* overloads */ OverloadIndex(605), }, { /* [69] */ - /* fn reverseBits[T : iu32](T) -> T */ - /* fn reverseBits[N : num, T : iu32](vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(667), + /* fn refract[N : num, T : f32_f16](vec, vec, T) -> vec */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(606), }, { /* [70] */ - /* fn round[T : f32_f16](@test_value(3.5) T) -> T */ - /* fn round[N : num, T : f32_f16](@test_value(3.5) vec) -> vec */ + /* fn reverseBits[T : iu32](T) -> T */ + /* fn reverseBits[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(669), + /* overloads */ OverloadIndex(518), }, { /* [71] */ - /* fn saturate[T : f32_f16](@test_value(2) T) -> T */ - /* fn saturate[T : f32_f16, N : num](@test_value(2) vec) -> vec */ + /* fn round[T : f32_f16](@test_value(3.5) T) -> T */ + /* fn round[N : num, T : f32_f16](@test_value(3.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(671), + /* overloads */ OverloadIndex(520), }, { /* [72] */ + /* fn saturate[T : f32_f16](@test_value(2) T) -> T */ + /* fn saturate[T : f32_f16, N : num](@test_value(2) vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(522), + }, + { + /* [73] */ /* fn select[T : scalar](T, T, bool) -> T */ /* fn select[T : scalar, N : num](vec, vec, bool) -> vec */ /* fn select[N : num, T : scalar](vec, vec, vec) -> vec */ /* num overloads */ 3, - /* overloads */ OverloadIndex(564), - }, - { - /* [73] */ - /* fn sign[T : fi32_f16](T) -> T */ - /* fn sign[N : num, T : fi32_f16](vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(673), + /* overloads */ OverloadIndex(412), }, { /* [74] */ - /* fn sin[T : f32_f16](@test_value(1.57079632679) T) -> T */ - /* fn sin[N : num, T : f32_f16](@test_value(1.57079632679) vec) -> vec */ + /* fn sign[T : fi32_f16](T) -> T */ + /* fn sign[N : num, T : fi32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(675), + /* overloads */ OverloadIndex(524), }, { /* [75] */ - /* fn sinh[T : f32_f16](T) -> T */ - /* fn sinh[N : num, T : f32_f16](vec) -> vec */ + /* fn sin[T : f32_f16](@test_value(1.57079632679) T) -> T */ + /* fn sin[N : num, T : f32_f16](@test_value(1.57079632679) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(677), + /* overloads */ OverloadIndex(526), }, { /* [76] */ - /* fn smoothstep[T : f32_f16](@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T */ - /* fn smoothstep[N : num, T : f32_f16](@test_value(2) vec, @test_value(4) vec, @test_value(3) vec) -> vec */ + /* fn sinh[T : f32_f16](T) -> T */ + /* fn sinh[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(679), + /* overloads */ OverloadIndex(528), }, { /* [77] */ - /* fn sqrt[T : f32_f16](T) -> T */ - /* fn sqrt[N : num, T : f32_f16](vec) -> vec */ + /* fn smoothstep[T : f32_f16](@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T */ + /* fn smoothstep[N : num, T : f32_f16](@test_value(2) vec, @test_value(4) vec, @test_value(3) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(681), + /* overloads */ OverloadIndex(530), }, { /* [78] */ - /* fn step[T : f32_f16](T, T) -> T */ - /* fn step[N : num, T : f32_f16](vec, vec) -> vec */ + /* fn sqrt[T : f32_f16](T) -> T */ + /* fn sqrt[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(683), + /* overloads */ OverloadIndex(532), }, { /* [79] */ - /* fn tan[T : f32_f16](T) -> T */ - /* fn tan[N : num, T : f32_f16](vec) -> vec */ + /* fn step[T : f32_f16](T, T) -> T */ + /* fn step[N : num, T : f32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(685), + /* overloads */ OverloadIndex(534), }, { /* [80] */ - /* fn tanh[T : f32_f16](T) -> T */ - /* fn tanh[N : num, T : f32_f16](vec) -> vec */ + /* fn tan[T : f32_f16](T) -> T */ + /* fn tan[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(687), + /* overloads */ OverloadIndex(536), }, { /* [81] */ - /* fn transpose[M : num, N : num, T : f32_f16](mat) -> mat */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(754), + /* fn tanh[T : f32_f16](T) -> T */ + /* fn tanh[N : num, T : f32_f16](vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(538), }, { /* [82] */ - /* fn trunc[T : f32_f16](@test_value(1.5) T) -> T */ - /* fn trunc[N : num, T : f32_f16](@test_value(1.5) vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(689), + /* fn transpose[M : num, N : num, T : f32_f16](mat) -> mat */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(607), }, { /* [83] */ - /* fn unpack2x16float(u32) -> vec2 */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(755), + /* fn trunc[T : f32_f16](@test_value(1.5) T) -> T */ + /* fn trunc[N : num, T : f32_f16](@test_value(1.5) vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(540), }, { /* [84] */ - /* fn unpack2x16snorm(u32) -> vec2 */ + /* fn unpack2x16float(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(756), + /* overloads */ OverloadIndex(608), }, { /* [85] */ - /* fn unpack2x16unorm(u32) -> vec2 */ + /* fn unpack2x16snorm(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(757), + /* overloads */ OverloadIndex(609), }, { /* [86] */ - /* fn unpack4x8snorm(u32) -> vec4 */ + /* fn unpack2x16unorm(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(758), + /* overloads */ OverloadIndex(610), }, { /* [87] */ - /* fn unpack4x8unorm(u32) -> vec4 */ + /* fn unpack4x8snorm(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(759), + /* overloads */ OverloadIndex(611), }, { /* [88] */ - /* fn unpack4xI8(u32) -> vec4 */ + /* fn unpack4x8unorm(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(612), }, { /* [89] */ - /* fn unpack4xU8(u32) -> vec4 */ + /* fn unpack4xI8(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(761), + /* overloads */ OverloadIndex(613), }, { /* [90] */ - /* fn storageBarrier() */ + /* fn unpack4xU8(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(762), + /* overloads */ OverloadIndex(614), }, { /* [91] */ - /* fn workgroupBarrier() */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(762), + /* fn addSat(u32, u32) -> u32 */ + /* fn addSat[N : num](vec, vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(542), }, { /* [92] */ - /* fn textureBarrier() */ + /* fn storageBarrier() */ /* num overloads */ 1, - /* overloads */ OverloadIndex(762), + /* overloads */ OverloadIndex(615), }, { /* [93] */ + /* fn workgroupBarrier() */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(615), + }, + { + /* [94] */ + /* fn textureBarrier() */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(615), + }, + { + /* [95] */ /* fn textureDimensions[T : fiu32](texture: texture_1d) -> u32 */ /* fn textureDimensions[T : fiu32, L : iu32](texture: texture_1d, level: L) -> u32 */ /* fn textureDimensions[T : fiu32](texture: texture_2d) -> vec2 */ @@ -19770,18 +15962,6 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureDimensions[T : fiu32, L : iu32](texture: texture_cube, level: L) -> vec2 */ /* fn textureDimensions[T : fiu32](texture: texture_cube_array) -> vec2 */ /* fn textureDimensions[T : fiu32, L : iu32](texture: texture_cube_array, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_1d_filtered) -> u32 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_1d_filtered, level: L) -> u32 */ - /* fn textureDimensions[K : texture_filter](texture: texture_2d_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_2d_filtered, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_2d_array_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_2d_array_filtered, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_3d_filtered) -> vec3 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_3d_filtered, level: L) -> vec3 */ - /* fn textureDimensions[K : texture_filter](texture: texture_cube_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_cube_filtered, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_cube_array_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_cube_array_filtered, level: L) -> vec2 */ /* fn textureDimensions[T : fiu32](texture: texture_multisampled_2d) -> vec2 */ /* fn textureDimensions(texture: texture_depth_2d) -> vec2 */ /* fn textureDimensions[L : iu32](texture: texture_depth_2d, level: L) -> vec2 */ @@ -19803,52 +15983,28 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureDimensions[F : texel_format, R : read](texture: texel_buffer) -> u32 */ /* fn textureDimensions[F : texel_format, W : writable](texture: texel_buffer) -> u32 */ /* fn textureDimensions(texture: texture_external) -> vec2 */ - /* num overloads */ 45, - /* overloads */ OverloadIndex(102), + /* num overloads */ 33, + /* overloads */ OverloadIndex(39), }, { - /* [94] */ + /* [96] */ /* fn textureGather[T : fiu32, C : iu32](@const component: C, texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureGather[T : fiu32, C : iu32, K : sampler_filter](@const component: C, texture: texture_2d, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, F : texture_filter, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, K : sampler_filter, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32](@const component: C, texture: texture_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : fiu32, C : iu32, K : sampler_filter](@const component: C, texture: texture_2d, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, F : texture_filter](@const component: C, texture: texture_2d_filtered, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, K : sampler_filter](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : fiu32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, F : texture_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : fiu32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, F : texture_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32](@const component: C, texture: texture_cube, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureGather[T : fiu32, C : iu32, K : sampler_filter](@const component: C, texture: texture_cube, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, F : texture_filter, C : iu32](@const component: C, texture: texture_cube_filtered, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, K : sampler_filter, C : iu32](@const component: C, texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, C : iu32](@const component: C, texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32, A : iu32](@const component: C, texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : fiu32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, F : texture_filter](@const component: C, texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32](@const component: C, texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ /* fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2) -> vec4 */ /* fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ /* fn textureGather[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ /* fn textureGather[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ /* fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> vec4 */ /* fn textureGather[A : iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* num overloads */ 36, - /* overloads */ OverloadIndex(270), + /* num overloads */ 12, + /* overloads */ OverloadIndex(179), }, { - /* [95] */ + /* [97] */ /* fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32) -> vec4 */ /* fn textureGatherCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32, @const offset: vec2) -> vec4 */ /* fn textureGatherCompare[A : iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2, array_index: A, depth_ref: f32) -> vec4 */ @@ -19856,152 +16012,76 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> vec4 */ /* fn textureGatherCompare[A : iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: A, depth_ref: f32) -> vec4 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(429), + /* overloads */ OverloadIndex(296), }, { - /* [96] */ + /* [98] */ /* fn textureNumLayers[T : fiu32](texture: texture_2d_array) -> u32 */ /* fn textureNumLayers[T : fiu32](texture: texture_cube_array) -> u32 */ - /* fn textureNumLayers[F : texture_filter](texture: texture_2d_array_filtered) -> u32 */ - /* fn textureNumLayers[F : texture_filter](texture: texture_cube_array_filtered) -> u32 */ /* fn textureNumLayers(texture: texture_depth_2d_array) -> u32 */ /* fn textureNumLayers(texture: texture_depth_cube_array) -> u32 */ /* fn textureNumLayers[F : texel_format, R : read](texture: texture_storage_2d_array) -> u32 */ /* fn textureNumLayers[F : texel_format, W : writable](texture: texture_storage_2d_array) -> u32 */ - /* num overloads */ 8, - /* overloads */ OverloadIndex(421), + /* num overloads */ 6, + /* overloads */ OverloadIndex(302), }, { - /* [97] */ + /* [99] */ /* fn textureNumLevels[T : fiu32](texture: texture_1d) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_2d) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_2d_array) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_3d) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_cube) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_cube_array) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_1d_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_2d_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_2d_array_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_3d_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_cube_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_cube_array_filtered) -> u32 */ /* fn textureNumLevels(texture: texture_depth_2d) -> u32 */ /* fn textureNumLevels(texture: texture_depth_2d_array) -> u32 */ /* fn textureNumLevels(texture: texture_depth_cube) -> u32 */ /* fn textureNumLevels(texture: texture_depth_cube_array) -> u32 */ - /* num overloads */ 16, - /* overloads */ OverloadIndex(346), + /* num overloads */ 10, + /* overloads */ OverloadIndex(227), }, { - /* [98] */ + /* [100] */ /* fn textureNumSamples[T : fiu32](texture: texture_multisampled_2d) -> u32 */ /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32 */ /* num overloads */ 2, - /* overloads */ OverloadIndex(691), + /* overloads */ OverloadIndex(544), }, { - /* [99] */ + /* [101] */ /* fn textureSample(texture: texture_1d, sampler: sampler, coords: f32) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_1d, sampler: sampler_filtered, coords: f32) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_1d_filtered, sampler: sampler, coords: f32) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32) -> vec4 */ - /* fn textureSample(texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32) -> vec4 */ /* fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSample(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ /* fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ /* fn textureSample[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[F : texture_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ /* fn textureSample[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[F : texture_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ /* fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ /* fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, @const offset: vec3) -> vec4 */ /* fn textureSample(texture: texture_cube, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ /* fn textureSample[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[F : texture_filter, A : iu32](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ /* fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2) -> f32 */ /* fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> f32 */ /* fn textureSample[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A) -> f32 */ /* fn textureSample[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> f32 */ /* fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> f32 */ /* fn textureSample[A : iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: A) -> f32 */ - /* num overloads */ 51, - /* overloads */ OverloadIndex(0), + /* num overloads */ 15, + /* overloads */ OverloadIndex(106), }, { - /* [100] */ + /* [102] */ /* fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32) -> vec4 */ /* fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleBias[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32) -> vec4 */ /* fn textureSampleBias[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ /* fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ /* fn textureSampleBias(texture: texture_cube, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ /* fn textureSampleBias[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, F : texture_filter](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* num overloads */ 40, - /* overloads */ OverloadIndex(190), + /* num overloads */ 8, + /* overloads */ OverloadIndex(256), }, { - /* [101] */ + /* [103] */ /* fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32) -> f32 */ /* fn textureSampleCompare(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32, @const offset: vec2) -> f32 */ /* fn textureSampleCompare[A : iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2, array_index: A, depth_ref: f32) -> f32 */ @@ -20009,10 +16089,10 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 */ /* fn textureSampleCompare[A : iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: A, depth_ref: f32) -> f32 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(435), + /* overloads */ OverloadIndex(308), }, { - /* [102] */ + /* [104] */ /* fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32) -> f32 */ /* fn textureSampleCompareLevel(texture: texture_depth_2d, sampler: sampler_comparison, coords: vec2, depth_ref: f32, @const offset: vec2) -> f32 */ /* fn textureSampleCompareLevel[A : iu32](texture: texture_depth_2d_array, sampler: sampler_comparison, coords: vec2, array_index: A, depth_ref: f32) -> f32 */ @@ -20020,122 +16100,50 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 */ /* fn textureSampleCompareLevel[A : iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: A, depth_ref: f32) -> f32 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(441), + /* overloads */ OverloadIndex(314), }, { - /* [103] */ + /* [105] */ /* fn textureSampleGrad(texture: texture_2d, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ /* fn textureSampleGrad(texture: texture_2d, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ /* fn textureSampleGrad[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ /* fn textureSampleGrad[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ /* fn textureSampleGrad(texture: texture_3d, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ /* fn textureSampleGrad(texture: texture_3d, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ /* fn textureSampleGrad(texture: texture_cube, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ /* fn textureSampleGrad[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32, F : texture_filter](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* num overloads */ 40, - /* overloads */ OverloadIndex(230), + /* num overloads */ 8, + /* overloads */ OverloadIndex(264), }, { - /* [104] */ + /* [106] */ /* fn textureSampleLevel(texture: texture_1d, sampler: sampler, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_1d, sampler: sampler_filtered, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_1d_filtered, sampler: sampler, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32, level: f32) -> vec4 */ /* fn textureSampleLevel(texture: texture_2d, sampler: sampler, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32) -> vec4 */ /* fn textureSampleLevel(texture: texture_2d, sampler: sampler, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleLevel[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32) -> vec4 */ /* fn textureSampleLevel[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleLevel(texture: texture_3d, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ /* fn textureSampleLevel(texture: texture_3d, sampler: sampler, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ /* fn textureSampleLevel(texture: texture_cube, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ /* fn textureSampleLevel[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, F : texture_filter](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, level: f32) -> vec4 */ /* fn textureSampleLevel[L : iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2, level: L) -> f32 */ /* fn textureSampleLevel[L : iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2, level: L, @const offset: vec2) -> f32 */ /* fn textureSampleLevel[A : iu32, L : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, level: L) -> f32 */ /* fn textureSampleLevel[A : iu32, L : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, level: L, @const offset: vec2) -> f32 */ /* fn textureSampleLevel[L : iu32](texture: texture_depth_cube, sampler: sampler, coords: vec3, level: L) -> f32 */ /* fn textureSampleLevel[A : iu32, L : iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: A, level: L) -> f32 */ - /* num overloads */ 51, - /* overloads */ OverloadIndex(51), + /* num overloads */ 15, + /* overloads */ OverloadIndex(121), }, { - /* [105] */ + /* [107] */ /* fn textureSampleBaseClampToEdge(texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ /* fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2) -> vec4 */ - /* num overloads */ 6, - /* overloads */ OverloadIndex(447), + /* num overloads */ 2, + /* overloads */ OverloadIndex(546), }, { - /* [106] */ + /* [108] */ /* fn textureStore[C : iu32, F : f32_texel_format, W : writable](texture: texture_storage_1d, coords: C, value: vec4) */ /* fn textureStore[C : iu32, F : f32_texel_format, W : writable](texture: texture_storage_2d, coords: vec2, value: vec4) */ /* fn textureStore[C : iu32, F : f32_texel_format, W : writable, A : iu32](texture: texture_storage_2d_array, coords: vec2, array_index: A, value: vec4) */ @@ -20152,18 +16160,14 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureStore[C : iu32, F : u32_texel_format, W : writable](texture: texture_storage_3d, coords: vec3, value: vec4) */ /* fn textureStore[C : iu32, F : u32_texel_format, RW : read_write](texture: texel_buffer, coords: C, value: vec4) */ /* num overloads */ 15, - /* overloads */ OverloadIndex(362), + /* overloads */ OverloadIndex(136), }, { - /* [107] */ + /* [109] */ /* fn textureLoad[T : fiu32, C : iu32, L : iu32](texture: texture_1d, coords: C, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, L : iu32](texture: texture_2d, coords: vec2, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, A : iu32, L : iu32](texture: texture_2d_array, coords: vec2, array_index: A, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, L : iu32](texture: texture_3d, coords: vec3, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, L : iu32, F : texture_filter](texture: texture_1d_filtered, coords: C, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, L : iu32, F : texture_filter](texture: texture_2d_filtered, coords: vec2, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, A : iu32, L : iu32, F : texture_filter](texture: texture_2d_array_filtered, coords: vec2, array_index: A, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, L : iu32, F : texture_filter](texture: texture_3d_filtered, coords: vec3, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, S : iu32](texture: texture_multisampled_2d, coords: vec2, sample_index: S) -> vec4 */ /* fn textureLoad[C : iu32, L : iu32](texture: texture_depth_2d, coords: vec2, level: L) -> f32 */ /* fn textureLoad[C : iu32, A : iu32, L : iu32](texture: texture_depth_2d_array, coords: vec2, array_index: A, level: L) -> f32 */ @@ -20199,402 +16203,423 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureLoad[C : iu32, F : f32_texel_format, RW : read_write](texture: texel_buffer, coords: C) -> vec4 */ /* fn textureLoad[C : iu32, F : i32_texel_format, RW : read_write](texture: texel_buffer, coords: C) -> vec4 */ /* fn textureLoad[C : iu32, F : u32_texel_format, RW : read_write](texture: texel_buffer, coords: C) -> vec4 */ - /* num overloads */ 43, - /* overloads */ OverloadIndex(147), - }, - { - /* [108] */ - /* fn inputAttachmentLoad[T : fiu32](input_attachment: input_attachment) -> vec4 */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(763), - }, - { - /* [109] */ - /* fn atomicLoad[T : iu32, S : workgroup_or_storage](ptr, read_write>) -> T */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(764), + /* num overloads */ 39, + /* overloads */ OverloadIndex(0), }, { /* [110] */ - /* fn atomicStore[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) */ + /* fn inputAttachmentLoad[T : fiu32](input_attachment: input_attachment) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(765), + /* overloads */ OverloadIndex(616), }, { /* [111] */ - /* fn atomicAdd[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicLoad[T : iu32, S : workgroup_or_storage](ptr, read_write>) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(617), }, { /* [112] */ - /* fn atomicSub[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicStore[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(618), }, { /* [113] */ - /* fn atomicMax[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicAdd[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(619), }, { /* [114] */ - /* fn atomicMin[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicSub[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(619), }, { /* [115] */ - /* fn atomicAnd[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicMax[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(619), }, { /* [116] */ - /* fn atomicOr[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicMin[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(619), }, { /* [117] */ - /* fn atomicXor[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicAnd[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(619), }, { /* [118] */ - /* fn atomicExchange[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ + /* fn atomicOr[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(619), }, { /* [119] */ - /* fn atomicCompareExchangeWeak[T : iu32, S : workgroup_or_storage](ptr, read_write>, T, T) -> __atomic_compare_exchange_result */ + /* fn atomicXor[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(767), + /* overloads */ OverloadIndex(619), }, { /* [120] */ - /* fn atomicStoreMax(ptr, read_write>, u64) */ + /* fn atomicExchange[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(768), + /* overloads */ OverloadIndex(619), }, { /* [121] */ - /* fn atomicStoreMin(ptr, read_write>, u64) */ + /* fn atomicCompareExchangeWeak[T : iu32, S : workgroup_or_storage](ptr, read_write>, T, T) -> __atomic_compare_exchange_result */ /* num overloads */ 1, - /* overloads */ OverloadIndex(768), + /* overloads */ OverloadIndex(620), }, { /* [122] */ - /* fn subgroupBallot(bool) -> vec4 */ + /* fn atomicStoreMax(ptr, read_write>, u64) */ /* num overloads */ 1, - /* overloads */ OverloadIndex(769), + /* overloads */ OverloadIndex(621), }, { /* [123] */ - /* fn subgroupElect() -> bool */ + /* fn atomicStoreMin(ptr, read_write>, u64) */ /* num overloads */ 1, - /* overloads */ OverloadIndex(770), + /* overloads */ OverloadIndex(621), }, { /* [124] */ - /* fn subgroupBroadcast[T : fiu32_f16](value: T, @const sourceLaneIndex: iu32) -> T */ - /* fn subgroupBroadcast[N : num, T : fiu32_f16](value: vec, @const sourceLaneIndex: iu32) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(693), + /* fn subgroupBallot(bool) -> vec4 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(622), }, { /* [125] */ - /* fn subgroupBroadcastFirst[T : fiu32_f16](value: T) -> T */ - /* fn subgroupBroadcastFirst[N : num, T : fiu32_f16](value: vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* fn subgroupElect() -> bool */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(623), }, { /* [126] */ - /* fn subgroupShuffle[T : fiu32_f16](value: T, sourceLaneIndex: iu32) -> T */ - /* fn subgroupShuffle[N : num, T : fiu32_f16](value: vec, sourceLaneIndex: iu32) -> vec */ + /* fn subgroupBroadcast[T : fiu32_f16](value: T, @const sourceLaneIndex: iu32) -> T */ + /* fn subgroupBroadcast[N : num, T : fiu32_f16](value: vec, @const sourceLaneIndex: iu32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(697), + /* overloads */ OverloadIndex(548), }, { /* [127] */ - /* fn subgroupShuffleXor[T : fiu32_f16](value: T, mask: u32) -> T */ - /* fn subgroupShuffleXor[N : num, T : fiu32_f16](value: vec, mask: u32) -> vec */ + /* fn subgroupBroadcastFirst[T : fiu32_f16](value: T) -> T */ + /* fn subgroupBroadcastFirst[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(699), + /* overloads */ OverloadIndex(550), }, { /* [128] */ - /* fn subgroupShuffleUp[T : fiu32_f16](value: T, delta: u32) -> T */ - /* fn subgroupShuffleUp[N : num, T : fiu32_f16](value: vec, delta: u32) -> vec */ + /* fn subgroupShuffle[T : fiu32_f16](value: T, sourceLaneIndex: iu32) -> T */ + /* fn subgroupShuffle[N : num, T : fiu32_f16](value: vec, sourceLaneIndex: iu32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(701), + /* overloads */ OverloadIndex(552), }, { /* [129] */ - /* fn subgroupShuffleDown[T : fiu32_f16](value: T, delta: u32) -> T */ - /* fn subgroupShuffleDown[N : num, T : fiu32_f16](value: vec, delta: u32) -> vec */ + /* fn subgroupShuffleXor[T : fiu32_f16](value: T, mask: u32) -> T */ + /* fn subgroupShuffleXor[N : num, T : fiu32_f16](value: vec, mask: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(701), + /* overloads */ OverloadIndex(554), }, { /* [130] */ - /* fn subgroupAdd[T : fiu32_f16](value: T) -> T */ - /* fn subgroupAdd[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupShuffleUp[T : fiu32_f16](value: T, delta: u32) -> T */ + /* fn subgroupShuffleUp[N : num, T : fiu32_f16](value: vec, delta: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(556), }, { /* [131] */ - /* fn subgroupInclusiveAdd[T : fiu32_f16](value: T) -> T */ - /* fn subgroupInclusiveAdd[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupShuffleDown[T : fiu32_f16](value: T, delta: u32) -> T */ + /* fn subgroupShuffleDown[N : num, T : fiu32_f16](value: vec, delta: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(556), }, { /* [132] */ - /* fn subgroupExclusiveAdd[T : fiu32_f16](value: T) -> T */ - /* fn subgroupExclusiveAdd[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupAdd[T : fiu32_f16](value: T) -> T */ + /* fn subgroupAdd[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(550), }, { /* [133] */ - /* fn subgroupMul[T : fiu32_f16](value: T) -> T */ - /* fn subgroupMul[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupInclusiveAdd[T : fiu32_f16](value: T) -> T */ + /* fn subgroupInclusiveAdd[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(550), }, { /* [134] */ - /* fn subgroupInclusiveMul[T : fiu32_f16](value: T) -> T */ - /* fn subgroupInclusiveMul[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupExclusiveAdd[T : fiu32_f16](value: T) -> T */ + /* fn subgroupExclusiveAdd[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(550), }, { /* [135] */ - /* fn subgroupExclusiveMul[T : fiu32_f16](value: T) -> T */ - /* fn subgroupExclusiveMul[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupMul[T : fiu32_f16](value: T) -> T */ + /* fn subgroupMul[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(550), }, { /* [136] */ - /* fn subgroupAnd[T : iu32](value: T) -> T */ - /* fn subgroupAnd[N : num, T : iu32](value: vec) -> vec */ + /* fn subgroupInclusiveMul[T : fiu32_f16](value: T) -> T */ + /* fn subgroupInclusiveMul[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(703), + /* overloads */ OverloadIndex(550), }, { /* [137] */ - /* fn subgroupOr[T : iu32](value: T) -> T */ - /* fn subgroupOr[N : num, T : iu32](value: vec) -> vec */ + /* fn subgroupExclusiveMul[T : fiu32_f16](value: T) -> T */ + /* fn subgroupExclusiveMul[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(703), + /* overloads */ OverloadIndex(550), }, { /* [138] */ - /* fn subgroupXor[T : iu32](value: T) -> T */ - /* fn subgroupXor[N : num, T : iu32](value: vec) -> vec */ + /* fn subgroupAnd[T : iu32](value: T) -> T */ + /* fn subgroupAnd[N : num, T : iu32](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(703), + /* overloads */ OverloadIndex(558), }, { /* [139] */ - /* fn subgroupMin[T : fiu32_f16](value: T) -> T */ - /* fn subgroupMin[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupOr[T : iu32](value: T) -> T */ + /* fn subgroupOr[N : num, T : iu32](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(558), }, { /* [140] */ - /* fn subgroupMax[T : fiu32_f16](value: T) -> T */ - /* fn subgroupMax[N : num, T : fiu32_f16](value: vec) -> vec */ + /* fn subgroupXor[T : iu32](value: T) -> T */ + /* fn subgroupXor[N : num, T : iu32](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(695), + /* overloads */ OverloadIndex(558), }, { /* [141] */ - /* fn subgroupAll(bool) -> bool */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(771), + /* fn subgroupMin[T : fiu32_f16](value: T) -> T */ + /* fn subgroupMin[N : num, T : fiu32_f16](value: vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(550), }, { /* [142] */ - /* fn subgroupAny(bool) -> bool */ - /* num overloads */ 1, - /* overloads */ OverloadIndex(771), + /* fn subgroupMax[T : fiu32_f16](value: T) -> T */ + /* fn subgroupMax[N : num, T : fiu32_f16](value: vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(550), }, { /* [143] */ - /* fn quadBroadcast[T : fiu32_f16](e: T, @const id: iu32) -> T */ - /* fn quadBroadcast[N : num, T : fiu32_f16](e: vec, @const id: iu32) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(705), + /* fn subgroupAll(bool) -> bool */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(624), }, { /* [144] */ - /* fn quadSwapX[T : fiu32_f16](e: T) -> T */ - /* fn quadSwapX[N : num, T : fiu32_f16](e: vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(707), + /* fn subgroupAny(bool) -> bool */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(624), }, { /* [145] */ - /* fn quadSwapY[T : fiu32_f16](e: T) -> T */ - /* fn quadSwapY[N : num, T : fiu32_f16](e: vec) -> vec */ + /* fn quadBroadcast[T : fiu32_f16](e: T, @const id: iu32) -> T */ + /* fn quadBroadcast[N : num, T : fiu32_f16](e: vec, @const id: iu32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(707), + /* overloads */ OverloadIndex(560), }, { /* [146] */ - /* fn quadSwapDiagonal[T : fiu32_f16](e: T) -> T */ - /* fn quadSwapDiagonal[N : num, T : fiu32_f16](e: vec) -> vec */ + /* fn quadSwapX[T : fiu32_f16](e: T) -> T */ + /* fn quadSwapX[N : num, T : fiu32_f16](e: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(707), + /* overloads */ OverloadIndex(562), }, { /* [147] */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num](ptr, readable>, offset: u32, @const col_major: bool, stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num](ptr, readable>, offset: u32, @const col_major: bool, stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num](ptr, readable>, offset: u32, @const col_major: bool, stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num](ptr, readable>, offset: u32, @const col_major: bool, stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num](ptr, readable>, offset: u32, @const col_major: bool, stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num](ptr, readable>, offset: u32, @const col_major: bool, stride: u32) -> T */ - /* num overloads */ 6, - /* overloads */ OverloadIndex(453), + /* fn quadSwapY[T : fiu32_f16](e: T) -> T */ + /* fn quadSwapY[N : num, T : fiu32_f16](e: vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(562), }, { /* [148] */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ - /* num overloads */ 6, - /* overloads */ OverloadIndex(459), + /* fn quadSwapDiagonal[T : fiu32_f16](e: T) -> T */ + /* fn quadSwapDiagonal[N : num, T : fiu32_f16](e: vec) -> vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(562), }, { /* [149] */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* num overloads */ 12, + /* overloads */ OverloadIndex(191), + }, + { + /* [150] */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* num overloads */ 12, + /* overloads */ OverloadIndex(203), + }, + { + /* [151] */ /* fn subgroupMatrixMultiply[T : f16, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiply[T : f32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiply[T : iu8, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiply[T : iu32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 4, - /* overloads */ OverloadIndex(529), + /* overloads */ OverloadIndex(389), }, { - /* [150] */ + /* [152] */ /* fn subgroupMatrixMultiplyAccumulate[T : f16, TR : f32_f16, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiplyAccumulate[T : f32, TR : f32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiplyAccumulate[T : iu8, TR : iu32_iu8, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiplyAccumulate[T : iu32, TR : iu32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 4, - /* overloads */ OverloadIndex(533), + /* overloads */ OverloadIndex(393), }, { - /* [151] */ + /* [153] */ /* fn subgroupMatrixScalarAdd[K : subgroup_matrix_kind, T : fiu32_f16, C : num, R : num](m: subgroup_matrix, s: T) -> subgroup_matrix */ /* fn subgroupMatrixScalarAdd[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, s: i32) -> subgroup_matrix */ /* fn subgroupMatrixScalarAdd[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, s: u32) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(567), + /* overloads */ OverloadIndex(415), }, { - /* [152] */ + /* [154] */ /* fn subgroupMatrixScalarSubtract[K : subgroup_matrix_kind, T : fiu32_f16, C : num, R : num](m: subgroup_matrix, s: T) -> subgroup_matrix */ /* fn subgroupMatrixScalarSubtract[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, s: i32) -> subgroup_matrix */ /* fn subgroupMatrixScalarSubtract[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, s: u32) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(567), + /* overloads */ OverloadIndex(415), }, { - /* [153] */ + /* [155] */ /* fn subgroupMatrixScalarMultiply[K : subgroup_matrix_kind, T : fiu32_f16, C : num, R : num](m: subgroup_matrix, s: T) -> subgroup_matrix */ /* fn subgroupMatrixScalarMultiply[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, s: i32) -> subgroup_matrix */ /* fn subgroupMatrixScalarMultiply[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, s: u32) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(567), + /* overloads */ OverloadIndex(415), }, { - /* [154] */ + /* [156] */ /* fn bufferView[R : read, AS : uniform_or_storage, O : iu32](ptr, O) -> ptr */ /* fn bufferView[R : read, AS : uniform_or_storage, O : iu32, N : num](ptr, R>, O) -> ptr */ /* fn bufferView[W : read_write, AS : workgroup_or_storage, O : iu32](ptr, O) -> ptr */ /* fn bufferView[W : read_write, AS : workgroup_or_storage, O : iu32, N : num](ptr, W>, O) -> ptr */ - /* num overloads */ 4, - /* overloads */ OverloadIndex(537), + /* fn bufferView[R : read, AS : uniform_or_storage, O : iu32, C : iu32](ptr, O, C) -> ptr */ + /* fn bufferView[R : read, AS : uniform_or_storage, O : iu32, N : num, C : iu32](ptr, R>, O, C) -> ptr */ + /* fn bufferView[W : read_write, AS : workgroup_or_storage, O : iu32, C : iu32](ptr, O, C) -> ptr */ + /* fn bufferView[W : read_write, AS : workgroup_or_storage, O : iu32, N : num, C : iu32](ptr, W>, O, C) -> ptr */ + /* num overloads */ 8, + /* overloads */ OverloadIndex(272), }, { - /* [155] */ + /* [157] */ + /* fn bufferArrayView[R : read, AS : uniform_or_storage, O : iu32, S : iu32](ptr, O, S) -> ptr */ + /* fn bufferArrayView[R : read, AS : uniform_or_storage, N : num, O : iu32, S : iu32](ptr, R>, O, S) -> ptr */ + /* fn bufferArrayView[W : read_write, AS : workgroup_or_storage, O : iu32, S : iu32](ptr, O, S) -> ptr */ + /* fn bufferArrayView[W : read_write, AS : workgroup_or_storage, N : num, O : iu32, S : iu32](ptr, W>, O, S) -> ptr */ + /* fn bufferArrayView[R : read, AS : uniform_or_storage, O : iu32, S : iu32, C : iu32](ptr, O, S, C) -> ptr */ + /* fn bufferArrayView[R : read, AS : uniform_or_storage, N : num, O : iu32, S : iu32, C : iu32](ptr, R>, O, S, C) -> ptr */ + /* fn bufferArrayView[W : read_write, AS : workgroup_or_storage, O : iu32, S : iu32, C : iu32](ptr, O, S, C) -> ptr */ + /* fn bufferArrayView[W : read_write, AS : workgroup_or_storage, N : num, O : iu32, S : iu32, C : iu32](ptr, W>, O, S, C) -> ptr */ + /* num overloads */ 8, + /* overloads */ OverloadIndex(280), + }, + { + /* [158] */ /* fn bufferLength[R : read, AS : uniform_or_storage](ptr) -> u32 */ /* fn bufferLength[R : read, AS : uniform_or_storage, N : num](ptr, R>) -> u32 */ /* fn bufferLength[W : read_write, AS : workgroup_or_storage](ptr) -> u32 */ /* fn bufferLength[W : read_write, AS : workgroup_or_storage, N : num](ptr, W>) -> u32 */ - /* num overloads */ 4, - /* overloads */ OverloadIndex(541), + /* fn bufferLength[R : read, AS : uniform_or_storage, C : iu32](ptr, C) -> u32 */ + /* fn bufferLength[R : read, AS : uniform_or_storage, N : num, C : iu32](ptr, R>, C) -> u32 */ + /* fn bufferLength[W : read_write, AS : workgroup_or_storage, C : iu32](ptr, C) -> u32 */ + /* fn bufferLength[W : read_write, AS : workgroup_or_storage, N : num, C : iu32](ptr, W>, C) -> u32 */ + /* num overloads */ 8, + /* overloads */ OverloadIndex(288), }, { - /* [156] */ + /* [159] */ /* fn print[T : scalar](T) */ /* fn print[N : num, T : scalar](vec) */ /* num overloads */ 2, - /* overloads */ OverloadIndex(709), + /* overloads */ OverloadIndex(564), }, { - /* [157] */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ + /* [160] */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ + /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : sampler_filter, I : iu32](index: I) -> bool */ - /* num overloads */ 20, - /* overloads */ OverloadIndex(306), + /* num overloads */ 14, + /* overloads */ OverloadIndex(151), }, { - /* [158] */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ + /* [161] */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ + /* fn getResource[I : iu32](index: I) -> S */ /* fn getResource[I : iu32](index: I) -> S */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : sampler_filter, I : iu32](index: I) -> S */ - /* num overloads */ 20, - /* overloads */ OverloadIndex(326), + /* num overloads */ 14, + /* overloads */ OverloadIndex(165), }, }; @@ -20604,21 +16629,21 @@ constexpr IntrinsicInfo kUnaryOperators[] = { /* op !(bool) -> bool */ /* op ![N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(711), + /* overloads */ OverloadIndex(566), }, { /* [1] */ /* op ~[T : iu32](T) -> T */ /* op ~[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(713), + /* overloads */ OverloadIndex(568), }, { /* [2] */ /* op -[T : fi32_f16](T) -> T */ /* op -[T : fi32_f16, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(715), + /* overloads */ OverloadIndex(570), }, }; constexpr uint8_t kUnaryOperatorNot = 0; @@ -20634,7 +16659,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op +[T : fiu32_f16, N : num](T, vec) -> vec */ /* op +[T : f32_f16, N : num, M : num](mat, mat) -> mat */ /* num overloads */ 5, - /* overloads */ OverloadIndex(519), + /* overloads */ OverloadIndex(374), }, { /* [1] */ @@ -20644,7 +16669,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op -[T : fiu32_f16, N : num](T, vec) -> vec */ /* op -[T : f32_f16, N : num, M : num](mat, mat) -> mat */ /* num overloads */ 5, - /* overloads */ OverloadIndex(524), + /* overloads */ OverloadIndex(379), }, { /* [2] */ @@ -20658,7 +16683,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op *[T : f32_f16, C : num, R : num](vec, mat) -> vec */ /* op *[T : f32_f16, K : num, C : num, R : num](mat, mat) -> mat */ /* num overloads */ 9, - /* overloads */ OverloadIndex(403), + /* overloads */ OverloadIndex(247), }, { /* [3] */ @@ -20667,7 +16692,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op /[T : fiu32_f16, N : num](vec, T) -> vec */ /* op /[T : fiu32_f16, N : num](T, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(545), + /* overloads */ OverloadIndex(397), }, { /* [4] */ @@ -20676,14 +16701,14 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op %[T : fiu32_f16, N : num](vec, T) -> vec */ /* op %[T : fiu32_f16, N : num](T, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(549), + /* overloads */ OverloadIndex(401), }, { /* [5] */ /* op ^[T : iu32](T, T) -> T */ /* op ^[T : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(717), + /* overloads */ OverloadIndex(572), }, { /* [6] */ @@ -20692,7 +16717,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op &[T : iu32](T, T) -> T */ /* op &[T : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(553), + /* overloads */ OverloadIndex(405), }, { /* [7] */ @@ -20700,76 +16725,78 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op |[N : num](vec, vec) -> vec */ /* op |[T : iu32](T, T) -> T */ /* op |[T : iu32, N : num](vec, vec) -> vec */ - /* num overloads */ 4, - /* overloads */ OverloadIndex(557), + /* op |(u64, u64) -> u64 */ + /* num overloads */ 5, + /* overloads */ OverloadIndex(384), }, { /* [8] */ /* op &&(bool, bool) -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(772), + /* overloads */ OverloadIndex(625), }, { /* [9] */ /* op ||(bool, bool) -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(773), + /* overloads */ OverloadIndex(626), }, { /* [10] */ /* op ==[T : scalar](T, T) -> bool */ /* op ==[T : scalar, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(719), + /* overloads */ OverloadIndex(574), }, { /* [11] */ /* op !=[T : scalar](T, T) -> bool */ /* op !=[T : scalar, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(721), + /* overloads */ OverloadIndex(576), }, { /* [12] */ /* op <[T : fiu32_f16](T, T) -> bool */ /* op <[T : fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(723), + /* overloads */ OverloadIndex(578), }, { /* [13] */ /* op >[T : fiu32_f16](T, T) -> bool */ /* op >[T : fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(725), + /* overloads */ OverloadIndex(580), }, { /* [14] */ /* op <=[T : fiu32_f16](T, T) -> bool */ /* op <=[T : fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(727), + /* overloads */ OverloadIndex(582), }, { /* [15] */ /* op >=[T : fiu32_f16](T, T) -> bool */ /* op >=[T : fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(729), + /* overloads */ OverloadIndex(584), }, { /* [16] */ /* op <<[T : iu32](T, u32) -> T */ /* op <<[T : iu32, N : num](vec, vec) -> vec */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(731), + /* op <<(u64, u64) -> u64 */ + /* num overloads */ 3, + /* overloads */ OverloadIndex(418), }, { /* [17] */ /* op >>[T : iu32](T, u32) -> T */ /* op >>[T : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(733), + /* overloads */ OverloadIndex(586), }, }; constexpr uint8_t kBinaryOperatorPlus = 0; @@ -20798,7 +16825,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor i32(i32) -> i32 */ /* conv i32[T : scalar_no_i32](T) -> i32 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(570), + /* overloads */ OverloadIndex(421), }, { /* [1] */ @@ -20806,7 +16833,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor u32(u32) -> u32 */ /* conv u32[T : scalar_no_u32](T) -> u32 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(573), + /* overloads */ OverloadIndex(424), }, { /* [2] */ @@ -20814,7 +16841,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor f32(f32) -> f32 */ /* conv f32[T : scalar_no_f32](T) -> f32 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(576), + /* overloads */ OverloadIndex(427), }, { /* [3] */ @@ -20822,7 +16849,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor f16(f16) -> f16 */ /* conv f16[T : scalar_no_f16](T) -> f16 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(579), + /* overloads */ OverloadIndex(430), }, { /* [4] */ @@ -20830,7 +16857,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor bool(bool) -> bool */ /* conv bool[T : scalar_no_bool](T) -> bool */ /* num overloads */ 3, - /* overloads */ OverloadIndex(582), + /* overloads */ OverloadIndex(433), }, { /* [5] */ @@ -20840,11 +16867,12 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor vec2(x: T, y: T) -> vec2 */ /* conv vec2[U : scalar_no_f32](vec2) -> vec2 */ /* conv vec2[U : scalar_no_f16](vec2) -> vec2 */ + /* conv vec2[U : scalar_no_u16](vec2) -> vec2 */ /* conv vec2[U : scalar_no_i32](vec2) -> vec2 */ /* conv vec2[U : scalar_no_u32](vec2) -> vec2 */ /* conv vec2[U : scalar_no_bool](vec2) -> vec2 */ - /* num overloads */ 9, - /* overloads */ OverloadIndex(412), + /* num overloads */ 10, + /* overloads */ OverloadIndex(237), }, { /* [6] */ @@ -20856,11 +16884,12 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor vec3(x: T, yz: vec2) -> vec3 */ /* conv vec3[U : scalar_no_f32](vec3) -> vec3 */ /* conv vec3[U : scalar_no_f16](vec3) -> vec3 */ + /* conv vec3[U : scalar_no_u16](vec3) -> vec3 */ /* conv vec3[U : scalar_no_i32](vec3) -> vec3 */ /* conv vec3[U : scalar_no_u32](vec3) -> vec3 */ /* conv vec3[U : scalar_no_bool](vec3) -> vec3 */ - /* num overloads */ 11, - /* overloads */ OverloadIndex(392), + /* num overloads */ 12, + /* overloads */ OverloadIndex(215), }, { /* [7] */ @@ -20876,11 +16905,12 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor vec4(x: T, zyw: vec3) -> vec4 */ /* conv vec4[U : scalar_no_f32](vec4) -> vec4 */ /* conv vec4[U : scalar_no_f16](vec4) -> vec4 */ + /* conv vec4[U : scalar_no_u16](vec4) -> vec4 */ /* conv vec4[U : scalar_no_i32](vec4) -> vec4 */ /* conv vec4[U : scalar_no_u32](vec4) -> vec4 */ /* conv vec4[U : scalar_no_bool](vec4) -> vec4 */ - /* num overloads */ 15, - /* overloads */ OverloadIndex(377), + /* num overloads */ 16, + /* overloads */ OverloadIndex(90), }, { /* [8] */ @@ -20891,7 +16921,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat2x2(mat2x2) -> mat2x2 */ /* conv mat2x2(mat2x2) -> mat2x2 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(465), + /* overloads */ OverloadIndex(320), }, { /* [9] */ @@ -20902,7 +16932,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat2x3(mat2x3) -> mat2x3 */ /* conv mat2x3(mat2x3) -> mat2x3 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(471), + /* overloads */ OverloadIndex(326), }, { /* [10] */ @@ -20913,7 +16943,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat2x4(mat2x4) -> mat2x4 */ /* conv mat2x4(mat2x4) -> mat2x4 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(477), + /* overloads */ OverloadIndex(332), }, { /* [11] */ @@ -20924,7 +16954,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat3x2(mat3x2) -> mat3x2 */ /* conv mat3x2(mat3x2) -> mat3x2 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(483), + /* overloads */ OverloadIndex(338), }, { /* [12] */ @@ -20935,7 +16965,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat3x3(mat3x3) -> mat3x3 */ /* conv mat3x3(mat3x3) -> mat3x3 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(489), + /* overloads */ OverloadIndex(344), }, { /* [13] */ @@ -20946,7 +16976,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat3x4(mat3x4) -> mat3x4 */ /* conv mat3x4(mat3x4) -> mat3x4 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(495), + /* overloads */ OverloadIndex(350), }, { /* [14] */ @@ -20957,7 +16987,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat4x2(mat4x2) -> mat4x2 */ /* conv mat4x2(mat4x2) -> mat4x2 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(501), + /* overloads */ OverloadIndex(356), }, { /* [15] */ @@ -20968,7 +16998,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat4x3(mat4x3) -> mat4x3 */ /* conv mat4x3(mat4x3) -> mat4x3 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(507), + /* overloads */ OverloadIndex(362), }, { /* [16] */ @@ -20979,25 +17009,37 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat4x4(mat4x4) -> mat4x4 */ /* conv mat4x4(mat4x4) -> mat4x4 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(513), + /* overloads */ OverloadIndex(368), }, { /* [17] */ /* ctor subgroup_matrix_left() -> subgroup_matrix */ /* num overloads */ 1, - /* overloads */ OverloadIndex(774), + /* overloads */ OverloadIndex(627), }, { /* [18] */ /* ctor subgroup_matrix_right() -> subgroup_matrix */ /* num overloads */ 1, - /* overloads */ OverloadIndex(775), + /* overloads */ OverloadIndex(628), }, { /* [19] */ /* ctor subgroup_matrix_result() -> subgroup_matrix */ /* num overloads */ 1, - /* overloads */ OverloadIndex(776), + /* overloads */ OverloadIndex(629), + }, + { + /* [20] */ + /* conv u16[T : scalar_no_u16](T) -> i32 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(630), + }, + { + /* [21] */ + /* conv u64(u32) -> u64 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(631), }, }; diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/table.cc b/3rdparty/dawn/src/tint/lang/core/intrinsic/table.cc index c380837d8..40b8da81e 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/table.cc +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/table.cc @@ -30,14 +30,15 @@ #include #include #include +#include #include +#include #include "src/tint/lang/core/evaluation_stage.h" #include "src/tint/lang/core/intrinsic/table_data.h" #include "src/tint/lang/core/type/invalid.h" #include "src/tint/lang/core/type/manager.h" #include "src/tint/lang/core/type/void.h" -#include "src/tint/utils/containers/slice.h" #include "src/tint/utils/ice/ice.h" #include "src/tint/utils/macros/defer.h" #include "src/tint/utils/text/string_stream.h" @@ -84,10 +85,28 @@ static inline void SortCandidates(Candidates& candidates) { [&](const Candidate& a, const Candidate& b) { return a.score < b.score; }); } -/// Prints a list of types. -static void PrintTypeList(StyledText& ss, VectorRef types) { +/// Prints a list of template parameters. +static void PrintTemplateParamList(StyledText& ss, VectorRef params) { bool first = true; - for (auto* arg : types) { + for (auto arg : params) { + if (!first) { + ss << ", "; + } + first = false; + if (std::holds_alternative(arg)) { + auto* ty = std::get(arg); + ss << style::Type((ty != nullptr) ? ty->FriendlyName() : "undef"); + } else if (std::holds_alternative(arg)) { + auto major = std::get(arg); + ss << style::Enum(major); + } else { + ss << style::Type("undef"); + } + } +} +static void PrintTypeList(StyledText& ss, VectorRef args) { + bool first = true; + for (auto arg : args) { if (!first) { ss << ", "; } @@ -100,7 +119,7 @@ static void PrintTypeList(StyledText& ss, VectorRef typ /// @param context the intrinsic context /// @param intrinsic the intrinsic being called /// @param intrinsic_name the name of the intrinsic -/// @param template_args the template argument types +/// @param template_args the template arguments /// @param args the argument types /// @param earliest_eval_stage the earliest evaluation stage that the call can be made /// @param member_function `true` if the builtin should be a member function @@ -110,7 +129,7 @@ static void PrintTypeList(StyledText& ss, VectorRef typ Result MatchIntrinsic(Context& context, const IntrinsicInfo& intrinsic, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage, bool member_function, @@ -129,7 +148,7 @@ enum class ScoreMode { /// Evaluates the single overload for the provided argument types. /// @param context the intrinsic context /// @param overload the overload being considered -/// @param template_args the template argument types +/// @param template_args the template arguments /// @param args the argument types /// @tparam MODE the scoring mode to use. Passed as a template argument to ensure that the /// extremely-hot function is specialized without scoring logic for the common code path. @@ -137,7 +156,7 @@ enum class ScoreMode { template Candidate ScoreOverload(Context& context, const OverloadInfo& overload, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage); @@ -146,14 +165,14 @@ Candidate ScoreOverload(Context& context, /// @param context the intrinsic context /// @param candidates the list of candidate overloads /// @param intrinsic_name the name of the intrinsic -/// @param template_args the template argument types +/// @param template_args the template arguments /// @param args the argument types /// @see https://www.w3.org/TR/WGSL/#overload-resolution-section /// @returns the resolved Candidate. Result ResolveCandidate(Context& context, Candidates&& candidates, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args); // Prints the list of candidates for emitting diagnostics @@ -161,25 +180,25 @@ void PrintCandidates(StyledText& err, Context& context, VectorRef candidates, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args); /// Raises an ICE when no overload is a clear winner of overload resolution StyledText ErrAmbiguousOverload(Context& context, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args, VectorRef candidates); /// @return a string representing a call to a builtin with the given argument types. StyledText CallSignature(std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args) { StyledText out; out << style::Code << style::Function(intrinsic_name); if (!template_args.IsEmpty()) { out << "<"; - PrintTypeList(out, template_args); + PrintTemplateParamList(out, template_args); out << ">"; } out << "("; @@ -192,7 +211,7 @@ StyledText CallSignature(std::string_view intrinsic_name, Result MatchIntrinsic(Context& context, const IntrinsicInfo& intrinsic, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage, bool member_function, @@ -222,6 +241,7 @@ Result MatchIntrinsic(Context& context, // How many candidates matched? if (DAWN_UNLIKELY(num_matched == 0)) { // Perform the full scoring of each overload + size_t candidate_idx = 0; for (size_t overload_idx = 0; overload_idx < num_overloads; overload_idx++) { auto& overload = context.data[intrinsic.overloads + overload_idx]; @@ -230,7 +250,7 @@ Result MatchIntrinsic(Context& context, continue; } - candidates[overload_idx] = ScoreOverload( + candidates[candidate_idx++] = ScoreOverload( context, overload, template_args, args, earliest_eval_stage); } // Sort the candidates with the most promising first @@ -271,7 +291,7 @@ Result MatchIntrinsic(Context& context, template Candidate ScoreOverload(Context& context, const OverloadInfo& overload, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { #define MATCH_FAILURE(PENALTY) \ @@ -320,17 +340,40 @@ Candidate ScoreOverload(Context& context, auto num_tmpl_args = std::min(overload.num_explicit_templates, template_args.Length()); for (size_t i = 0; i < num_tmpl_args; ++i) { auto& tmpl = context.data[overload.templates + i]; - auto* type = template_args[i]; - if (auto* matcher_indices = context.data[tmpl.matcher_indices]) { - // Ensure type matches the template's matcher. - type = - context.Match(templates, overload, matcher_indices, earliest_eval_stage).Type(type); - if (!type) { + if (std::holds_alternative(template_args[i])) { + if (tmpl.kind != TemplateInfo::Kind::kType) { MATCH_FAILURE(kMismatchedExplicitTemplateTypePenalty); continue; } + auto* type = std::get(template_args[i]); + if (auto* matcher_indices = context.data[tmpl.matcher_indices]) { + // Ensure type matches the template's matcher. + type = context.Match(templates, overload, matcher_indices, earliest_eval_stage) + .Type(type); + if (!type) { + MATCH_FAILURE(kMismatchedExplicitTemplateTypePenalty); + continue; + } + } + templates.SetType(i, type); + } else if (std::holds_alternative(template_args[i])) { + if (tmpl.kind != TemplateInfo::Kind::kmajorness) { + MATCH_FAILURE(kMismatchedExplicitTemplateTypePenalty); + continue; + } + auto major = std::get(template_args[i]); + if (auto* matcher_indices = context.data[tmpl.matcher_indices]) { + auto num = context.Match(templates, overload, matcher_indices, earliest_eval_stage) + .Num(Number{static_cast(major)}); + if (major != static_cast(num.Value())) { + MATCH_FAILURE(kMismatchedExplicitTemplateTypePenalty); + continue; + } + } + templates.SetNum(i, Number{static_cast(major)}); + } else { + TINT_UNREACHABLE() << "Unhandled template kind"; } - templates.SetType(i, type); } // Invoke the matchers for each parameter <-> argument pair. @@ -384,7 +427,7 @@ Candidate ScoreOverload(Context& context, break; } - case TemplateInfo::Kind::kNumber: { + default: { // Checking that the inferred number matches the constraints on the // template. Increments `score` and assigns the template an invalid number if the // template numbers do not match their constraint matchers. @@ -415,7 +458,7 @@ Candidate ScoreOverload(Context& context, Result ResolveCandidate(Context& context, Candidates&& candidates, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args) { Vector best_ranks; best_ranks.Resize(args.Length(), 0xffffffff); @@ -481,7 +524,7 @@ void PrintCandidates(StyledText& ss, Context& context, VectorRef candidates, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args) { for (auto& candidate : candidates) { ss << " • "; @@ -492,7 +535,7 @@ void PrintCandidates(StyledText& ss, StyledText ErrAmbiguousOverload(Context& context, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args, VectorRef candidates) { StyledText err; @@ -515,7 +558,7 @@ void PrintCandidate(StyledText& ss, Context& context, const Candidate& candidate, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args) { // Restore old style before returning. auto prev_style = ss.Style(); @@ -538,9 +581,31 @@ void PrintCandidate(StyledText& ss, bool matched = false; if (i < template_args.Length()) { const MatcherIndex* matcher_indices = context.data[tmpl.matcher_indices]; - matched = (matcher_indices == nullptr) || - (context.Match(templates, overload, matcher_indices, earliest_eval_stage) - .Type(template_args[i]) != nullptr); + const core::type::Type* ty = nullptr; + uint32_t value = std::numeric_limits::max(); + // Check the template kind first. + if (std::holds_alternative(template_args[i])) { + ty = std::get(template_args[i]); + matched = tmpl.kind == TemplateInfo::Kind::kType; + } else if (std::holds_alternative(template_args[i])) { + value = static_cast(std::get(template_args[i])); + matched = tmpl.kind == TemplateInfo::Kind::kmajorness; + } else { + TINT_UNREACHABLE() << "Unhandled template kind"; + } + + if (matched) { + // Template kind matched so check the matcher if there's one. + if (matcher_indices) { + auto match = context.Match(templates, overload, matcher_indices, + earliest_eval_stage); + if (ty) { + matched = match.Type(ty) != nullptr; + } else { + matched = match.Num(Number{value}).IsValid(); + } + } + } } if (i > 0) { @@ -651,7 +716,7 @@ void PrintCandidate(StyledText& ss, Result LookupFn(Context& context, std::string_view intrinsic_name, size_t function_id, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { // Generates an error when no overloads match the provided arguments @@ -676,7 +741,7 @@ Result LookupFn(Context& context, Result LookupMemberFn(Context& context, std::string_view intrinsic_name, size_t function_id, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { // Generates an error when no overloads match the provided arguments @@ -853,7 +918,7 @@ Result LookupBinary(Context& context, Result LookupCtorConv(Context& context, std::string_view type_name, size_t type_id, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { // Generates an error when no overloads match the provided arguments diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/table.h b/3rdparty/dawn/src/tint/lang/core/intrinsic/table.h index 36fcf9685..7328d9e3f 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/table.h +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/table.h @@ -29,8 +29,10 @@ #define SRC_TINT_LANG_CORE_INTRINSIC_TABLE_H_ #include +#include #include #include +#include #include "src/tint/lang/core/binary_op.h" #include "src/tint/lang/core/enums.h" @@ -45,6 +47,9 @@ namespace tint::core::intrinsic { +// Note: Ensure any new enum here is also added to TemplateInfo::Kind (and sem.go). +using TemplateParameter = std::variant; + /// Overload describes a fully matched builtin function overload struct Overload { static constexpr size_t kNumFixedParameters = 8; @@ -139,7 +144,7 @@ void PrintCandidate(StyledText& ss, Context& context, const Candidate& candidate, std::string_view intrinsic_name, - VectorRef template_args, + VectorRef template_args, VectorRef args); /// Lookup looks for the builtin overload with the given signature, raising an error diagnostic @@ -159,7 +164,7 @@ void PrintCandidate(StyledText& ss, Result LookupFn(Context& context, std::string_view function_name, size_t function_id, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage); @@ -180,7 +185,7 @@ Result LookupFn(Context& context, Result LookupMemberFn(Context& context, std::string_view function_name, size_t function_id, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage); @@ -238,7 +243,7 @@ Result LookupBinary(Context& context, Result LookupCtorConv(Context& context, std::string_view type_name, size_t type_id, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage); @@ -272,7 +277,7 @@ struct Table { /// (EvaluationStage::kConstant). /// @return the resolved builtin function overload Result Lookup(BuiltinFn builtin_fn, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { std::string_view name = DIALECT::ToString(builtin_fn); @@ -296,7 +301,7 @@ struct Table { /// @return the resolved builtin function overload Result Lookup(BuiltinFn builtin_fn, const core::type::Type* object, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { // Push the object type into the argument list. @@ -362,7 +367,7 @@ struct Table { /// after shader creation time (EvaluationStage::kConstant). /// @return the resolved type constructor or conversion function overload Result Lookup(CtorConv type, - VectorRef template_args, + VectorRef template_args, VectorRef args, EvaluationStage earliest_eval_stage) { std::string_view name = DIALECT::ToString(type); @@ -393,6 +398,19 @@ struct Hasher { } }; +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, const core::intrinsic::TemplateParameter param) { + if (std::holds_alternative(param)) { + out << (std::get(param))->FriendlyName(); + } else if (std::holds_alternative(param)) { + out << std::get(param); + } else { + TINT_UNREACHABLE() << "Unhandled template kind"; + } + return out; +} + } // namespace tint #endif // SRC_TINT_LANG_CORE_INTRINSIC_TABLE_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/table_data.h b/3rdparty/dawn/src/tint/lang/core/intrinsic/table_data.h index 552902875..c2093ac3f 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/table_data.h +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/table_data.h @@ -31,13 +31,13 @@ #include #include +#include #include #include "src/tint/lang/core/constant/eval.h" #include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/evaluation_stage.h" #include "src/tint/utils/containers/enum_set.h" -#include "src/tint/utils/containers/slice.h" #include "src/tint/utils/text/styled_text.h" #include "src/tint/utils/text/text_style.h" @@ -173,7 +173,16 @@ struct ParameterInfo { /// TemplateInfo describes an template struct TemplateInfo { /// An enumerator of template kind - enum class Kind : uint8_t { kType, kNumber }; + /// The enum names don't match because they come directly from .def enums + enum class Kind : uint8_t { + kType, + kNumber, + kaccess, + kaddress_space, + ksubgroup_matrix_kind, + kmajorness, + ktexel_format, + }; /// Name of the template type (e.g. 'T') const char* name; @@ -540,23 +549,23 @@ struct TableData { } /// The list of templates used by the intrinsic overloads - const Slice templates; + const std::span templates; /// The list of type matcher indices - const Slice matcher_indices; + const std::span matcher_indices; /// The list of type matchers used by the intrinsic overloads - const Slice type_matchers; + const std::span type_matchers; /// The list of number matchers used by the intrinsic overloads - const Slice number_matchers; + const std::span number_matchers; /// The list of parameters used by the intrinsic overloads - const Slice parameters; + const std::span parameters; /// The list of overloads used by the intrinsics - const Slice overloads; + const std::span overloads; /// The list of constant evaluation functions used by the intrinsics - const Slice const_eval_functions; + const std::span const_eval_functions; /// The type constructor and convertor intrinsics - const Slice ctor_conv; + const std::span ctor_conv; /// The builtin function intrinsic - const Slice builtins; + const std::span builtins; /// The IntrinsicInfo for the binary operator 'plus' const IntrinsicInfo& binary_plus; /// The IntrinsicInfo for the binary operator 'minus' @@ -605,6 +614,7 @@ struct TableData { const IntrinsicInfo& unary_and; }; +// Incrementing matcher_indices_ triggers this warning. This code is performance critical. TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); const core::type::Type* MatchState::Type(const core::type::Type* ty) { TypeMatcherIndex matcher_index{(*matcher_indices_++).value}; diff --git a/3rdparty/dawn/src/tint/lang/core/intrinsic/type_matchers.h b/3rdparty/dawn/src/tint/lang/core/intrinsic/type_matchers.h index d89ee23ae..d0fdc5dc8 100644 --- a/3rdparty/dawn/src/tint/lang/core/intrinsic/type_matchers.h +++ b/3rdparty/dawn/src/tint/lang/core/intrinsic/type_matchers.h @@ -156,7 +156,7 @@ inline bool MatchVec(intrinsic::MatchState&, } template -inline bool MatchVec(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) { +inline constexpr bool MatchVec(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) { if (ty->Is()) { T = ty; return true; @@ -235,7 +235,7 @@ inline bool MatchMat(intrinsic::MatchState&, } template -inline bool MatchMat(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) { +inline constexpr bool MatchMat(intrinsic::MatchState&, const type::Type* ty, const type::Type*& T) { if (ty->Is()) { T = ty; return true; @@ -511,38 +511,13 @@ inline bool MatchSampler(intrinsic::MatchState&, const type::Type* ty) { if (ty->Is()) { return true; } - return ty->Is([](const type::Sampler* s) { - return s->Kind() == type::SamplerKind::kSampler && - s->Filtering() == SamplerFiltering::kUndefined; - }); + return ty->Is([](const type::Sampler* s) { return s->Kind() == type::SamplerKind::kSampler; }); } inline const type::Sampler* BuildSampler(intrinsic::MatchState& state, const type::Type*) { return state.types.sampler(); } -inline bool MatchSamplerFiltered(intrinsic::MatchState&, - const type::Type* ty, - intrinsic::Number& F) { - if (ty->Is()) { - F = intrinsic::Number::any; - return true; - } - if (auto* s = ty->As()) { - if (s->Filtering() != SamplerFiltering::kUndefined) { - F = intrinsic::Number(static_cast(s->Filtering())); - return true; - } - } - return false; -} - -inline const type::Sampler* BuildSamplerFiltered(intrinsic::MatchState& state, - const type::Type*, - intrinsic::Number& F) { - return state.types.sampler(static_cast(F.Value())); -} - inline bool MatchSamplerComparison(intrinsic::MatchState&, const type::Type* ty) { if (ty->Is()) { return true; @@ -565,7 +540,7 @@ inline bool MatchTexture(intrinsic::MatchState&, return true; } if (auto* v = ty->As()) { - if (v->Dim() == dim && v->Filterable() == TextureFilterable::kUndefined) { + if (v->Dim() == dim) { T = v->Type(); return true; } @@ -593,50 +568,6 @@ DECLARE_SAMPLED_TEXTURE(Cube, type::TextureDimension::kCube) DECLARE_SAMPLED_TEXTURE(CubeArray, type::TextureDimension::kCubeArray) #undef DECLARE_SAMPLED_TEXTURE -inline bool MatchTextureFiltered(intrinsic::MatchState&, - const type::Type* ty, - type::TextureDimension dim, - const type::Type*& T, - intrinsic::Number& F) { - if (ty->Is()) { - T = ty; - F = intrinsic::Number::any; - return true; - } - if (auto* v = ty->As()) { - if (v->Dim() == dim && v->Filterable() != TextureFilterable::kUndefined) { - T = v->Type(); - F = intrinsic::Number(static_cast(v->Filterable())); - return true; - } - } - return false; -} - -#define JOIN2(a, b, c) a##b##c - -#define DECLARE_SAMPLED_TEXTURE_FILTERED(suffix, dim) \ - inline bool JOIN2(MatchTexture, suffix, Filtered)(intrinsic::MatchState & state, \ - const type::Type* ty, const type::Type*& T, \ - intrinsic::Number& F) { \ - return MatchTextureFiltered(state, ty, dim, T, F); \ - } \ - inline const type::SampledTexture* JOIN2(BuildTexture, suffix, Filtered)( \ - intrinsic::MatchState & state, const type::Type*, const type::Type* T, \ - intrinsic::Number& F) { \ - return state.types.sampled_texture(dim, T, \ - static_cast(F.Value())); \ - } - -DECLARE_SAMPLED_TEXTURE_FILTERED(1D, type::TextureDimension::k1d) -DECLARE_SAMPLED_TEXTURE_FILTERED(2D, type::TextureDimension::k2d) -DECLARE_SAMPLED_TEXTURE_FILTERED(2DArray, type::TextureDimension::k2dArray) -DECLARE_SAMPLED_TEXTURE_FILTERED(3D, type::TextureDimension::k3d) -DECLARE_SAMPLED_TEXTURE_FILTERED(Cube, type::TextureDimension::kCube) -DECLARE_SAMPLED_TEXTURE_FILTERED(CubeArray, type::TextureDimension::kCubeArray) -#undef DECLARE_SAMPLED_TEXTURE_FILTERED -#undef JOIN2 - inline bool MatchTextureMultisampled(intrinsic::MatchState&, const type::Type* ty, type::TextureDimension dim, diff --git a/3rdparty/dawn/src/tint/lang/core/ir/access.h b/3rdparty/dawn/src/tint/lang/core/ir/access.h index 30a816ee2..aa7beaf9a 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/access.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/access.h @@ -28,6 +28,7 @@ #ifndef SRC_TINT_LANG_CORE_IR_ACCESS_H_ #define SRC_TINT_LANG_CORE_IR_ACCESS_H_ +#include #include #include "src/tint/lang/core/ir/operand_instruction.h" @@ -77,11 +78,11 @@ class Access final : public Castable> { void AddIndex(Value* idx) { AddOperand(operands_.Length(), idx); } /// @returns the accessor indices - tint::Slice Indices() { return operands_.Slice().Offset(kIndicesOperandOffset); } + std::span Indices() { return operands_.AsSpan().subspan(kIndicesOperandOffset); } /// @returns the accessor indices - tint::Slice Indices() const { - return operands_.Slice().Offset(kIndicesOperandOffset); + std::span Indices() const { + return operands_.AsSpan().subspan(kIndicesOperandOffset); } /// Removes the last index from the access indices diff --git a/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.cc b/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.cc index 9cdbf9b74..af5521d4c 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.cc @@ -27,36 +27,104 @@ #include "src/tint/lang/core/ir/analysis/for_loop_analysis.h" +#include #include #include "src/tint/lang/core/ir/access.h" #include "src/tint/lang/core/ir/binary.h" -#include "src/tint/lang/core/ir/bitcast.h" #include "src/tint/lang/core/ir/builtin_call.h" #include "src/tint/lang/core/ir/exit_if.h" #include "src/tint/lang/core/ir/exit_loop.h" #include "src/tint/lang/core/ir/function.h" #include "src/tint/lang/core/ir/if.h" -#include "src/tint/lang/core/ir/let.h" #include "src/tint/lang/core/ir/load.h" #include "src/tint/lang/core/ir/load_vector_element.h" #include "src/tint/lang/core/ir/loop.h" #include "src/tint/lang/core/ir/multi_in_block.h" +#include "src/tint/lang/core/ir/next_iteration.h" #include "src/tint/lang/core/ir/store.h" #include "src/tint/lang/core/ir/swizzle.h" -#include "src/tint/lang/core/ir/traverse.h" #include "src/tint/lang/core/ir/unary.h" #include "src/tint/lang/core/ir/value.h" -#include "src/tint/lang/core/ir/var.h" -#include "src/tint/lang/core/type/i32.h" -#include "src/tint/lang/core/type/pointer.h" -#include "src/tint/lang/core/type/type.h" -#include "src/tint/lang/core/type/u32.h" #include "src/tint/utils/containers/hashset.h" -#include "src/tint/utils/rtti/switch.h" namespace tint::core::ir::analysis { +namespace { + +std::optional> SinkChain( + const core::ir::Instruction* root) { + Hashset sink_chain{root}; + const Instruction* inst = root->prev; + while (inst) { + const auto& results = inst->Results(); + if (results.Length() != 1u) { + // We do not support more than one result for simplicity. + return std::nullopt; + } + + // Check that the instruction can be inlined as an expression (i.e. it either loads or + // operates on values). + if (!inst->IsAnyOf()) { + return std::nullopt; + } + + for (const auto& each_usage : inst->Result()->UsagesUnsorted()) { + // All usages must sink into the root instruction. + if (!each_usage->instruction || !sink_chain.Contains(each_usage->instruction)) { + return std::nullopt; + } + } + sink_chain.Add(inst); + inst = inst->prev; + } + return sink_chain; +} + +const core::ir::Store* GetContinuingSimpleLoopUpdate(const Loop* loop) { + // Check whether the continuing block can be embedded in a for-loop update statement. + // We can do this if the following conditions hold: + // - the last instruction of the continuing block is a next_iteration with no operands + // - the preceding instruction is a store + // - all other instructions in the block sink into that store + // - none of these instructions will be emitted as statements (e.g. var declarations) + // - none of the operands to these instructions are defined in the loop body + + if (!loop->Continuing() || loop->Continuing()->IsEmpty()) { + return nullptr; + } + auto* next_iteration = loop->Continuing()->Back()->As(); + if (!next_iteration || !next_iteration->Operands().IsEmpty()) { + return nullptr; + } + + auto* store = As(next_iteration->prev); + if (!store) { + return nullptr; + } + + auto sink_chain = SinkChain(store); + if (!sink_chain) { + return nullptr; + } + + // If an operand was defined in the loop body, then sinking may violate scoping rules. + for (auto inst : *sink_chain) { + for (auto* operand : inst->Operands()) { + if (auto* result = operand->As()) { + if (result->Instruction()->Block() == loop->Body()) { + return nullptr; + } + } + } + } + + return store; +} + +} // namespace + void ForLoopAnalysis::AttemptForLoopDeduction(const Loop* loop) { // Find the first 'if' which should be the condition for the for-loop. // Order here is critical since instructions in blocks are forward dependencies. @@ -74,46 +142,25 @@ void ForLoopAnalysis::AttemptForLoopDeduction(const Loop* loop) { // moving into conditional). return; } - } else if (inst->Is() || inst->Is() || - inst->Is() || inst->Is() || - inst->Is() || inst->Is() || - inst->Is()) { - // Allowed instructions since either load or operate on values (side effect free). - continue; - } else { - // Conservatively fail for all other functions that could potentially store/mutate - // memory. - return; } } if (!if_to_remove) { return; } - Hashset sink_chain; - // Add the 'if' instruction to set to avoid adding it to the body. - sink_chain.Add(if_to_remove); - const Instruction* inst = if_to_remove->prev; - while (inst) { - const auto& results = inst->Results(); - if (results.Length() != 1u) { - // We do not support more than one result for simplicity. - return; - } - - for (const auto& each_usage : inst->Result()->UsagesUnsorted()) { - // All usages must sink into the condition of the if - if (!each_usage->instruction || !sink_chain.Contains(each_usage->instruction)) { - return; - } - } - sink_chain.Add(inst); - inst = inst->prev; + // Check that all instructions that precede the condition feed into it. + auto sink_chain = SinkChain(if_to_remove); + if (!sink_chain) { + return; } - body_removed_instructions = std::move(sink_chain); + body_removed_instructions = std::move(sink_chain.value()); + // Valid condition found. Success criteria for condition hoisting. for_condition = if_to_remove->Condition(); + + // Now check whether the continuing block can be embedded in a for-loop update statement. + continuing_update_store = GetContinuingSimpleLoopUpdate(loop); } ForLoopAnalysis::ForLoopAnalysis(const Loop& loop) { diff --git a/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.h b/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.h index a6049f7fb..c318d3eec 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/analysis/for_loop_analysis.h @@ -28,12 +28,8 @@ #ifndef SRC_TINT_LANG_CORE_IR_ANALYSIS_FOR_LOOP_ANALYSIS_H_ #define SRC_TINT_LANG_CORE_IR_ANALYSIS_FOR_LOOP_ANALYSIS_H_ -#include -#include - -#include "src/tint/lang/core/ir/if.h" #include "src/tint/lang/core/ir/loop.h" -#include "src/tint/lang/core/ir/var.h" +#include "src/tint/lang/core/ir/store.h" #include "src/tint/utils/ice/ice.h" namespace tint::core::ir::analysis { @@ -61,11 +57,15 @@ class ForLoopAnalysis { return body_removed_instructions.Contains(inst); } + /// @returns the store in a simple continuing block that can be used as a for-loop update + const core::ir::Store* GetContinuingUpdateStore() { return continuing_update_store; } + private: void AttemptForLoopDeduction(const Loop* loop); Hashset body_removed_instructions; const core::ir::Value* for_condition = nullptr; + const core::ir::Store* continuing_update_store = nullptr; }; } // namespace tint::core::ir::analysis diff --git a/3rdparty/dawn/src/tint/lang/core/ir/analysis/integer_range_analysis.cc b/3rdparty/dawn/src/tint/lang/core/ir/analysis/integer_range_analysis.cc index 290547ac6..b3e49e800 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/analysis/integer_range_analysis.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/analysis/integer_range_analysis.cc @@ -167,7 +167,7 @@ struct IntegerRangeAnalysisImpl { if (!function_param) { return {}; } - if (access->Indices().Length() > 1) { + if (access->Indices().size() > 1) { return {}; } if (!access->Indices()[0]->As()) { diff --git a/3rdparty/dawn/src/tint/lang/core/ir/analysis/loop_analysis.cc b/3rdparty/dawn/src/tint/lang/core/ir/analysis/loop_analysis.cc index 85c742d8d..6a3b48f03 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/analysis/loop_analysis.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/analysis/loop_analysis.cc @@ -28,7 +28,7 @@ #include "src/tint/lang/core/ir/analysis/loop_analysis.h" #include "src/tint/lang/core/ir/binary.h" -#include "src/tint/lang/core/ir/bitcast.h" +#include "src/tint/lang/core/ir/core_builtin_call.h" #include "src/tint/lang/core/ir/exit_loop.h" #include "src/tint/lang/core/ir/function.h" #include "src/tint/lang/core/ir/if.h" @@ -62,8 +62,13 @@ InstClass* As(Value* val) { /// Returns the value, after unwrapping all bitcasts. Value* UnwrapBitcast(Value* val) { - while (auto* bitcast = As(val)) { - val = bitcast->Val(); + while (auto* inst_res = val->As()) { + auto* call = inst_res->Instruction()->As(); + if (call && call->Func() == core::BuiltinFn::kBitcast) { + val = call->Args()[0]; + continue; + } + break; } return val; } @@ -185,12 +190,12 @@ struct LoopAnalysisImpl { for (auto* inst : *loop.Body()) { // The Switch returns `true` if more instructions should be checked, otherwise `false`. bool keep_going = Switch( - inst, // - [&](Load*) { return true; }, // - [&](Bitcast*) { return true; }, // - [&](Binary*) { return true; }, // + inst, // + [&](Load*) { return true; }, // + [&](CoreBuiltinCall* c) { return c->Func() == core::BuiltinFn::kBitcast; }, // + [&](Binary*) { return true; }, // [&](If* i) { - if (IsBreakIfOnIndex(loop, i, index)) { + if (IsBreakIfOnIndex(i, index)) { // The loop is finite. has_break_if = true; } @@ -206,7 +211,7 @@ struct LoopAnalysisImpl { } /// @returns `true` if @p is a break-if construct that exits the loop based on @p index. - bool IsBreakIfOnIndex(const Loop& loop, If* i, Var& index) { + bool IsBreakIfOnIndex(If* i, Var& index) { // Returns `true` if the given value is a load of the index variable. auto is_index = [&index](Value* v) { if (auto* load = As(UnwrapBitcast(v))) { @@ -214,18 +219,6 @@ struct LoopAnalysisImpl { } return false; }; - // Returns `true` if the given value an immutable value declared before the loop body. - auto is_immutable_before_body = [&loop](Value* v) { - return tint::Switch( - UnwrapBitcast(v), // - [](ir::Constant*) { return true; }, // - [](ir::FunctionParam*) { return true; }, // - [&](ir::InstructionResult* r) { - auto* let = r->Instruction()->As(); - return let && let->Block() != loop.Body(); - } // - ); - }; auto is_constant_i32_or_u32 = [](Value* v) { auto* constant_value = v->As(); if (!constant_value) { @@ -235,10 +228,53 @@ struct LoopAnalysisImpl { }; auto is_capable_binary_for_loop_exit = [&](Binary* binary) { switch (binary->Op()) { - case BinaryOp::kLessThan: + case BinaryOp::kLessThan: { + if (is_index(binary->LHS()) && is_constant_i32_or_u32(binary->RHS())) { + // index < kConstantValue + // If `kConstantValue` is the lowest possible value then the expression is + // always false. + auto* constant_value = binary->RHS()->As()->Value(); + if (constant_value->Type()->Is()) { + return constant_value->ValueAs() > i32::kLowestValue; + } + TINT_ASSERT(constant_value->Type()->Is()); + return constant_value->ValueAs() > u32::kLowestValue; + } else if (is_index(binary->RHS()) && is_constant_i32_or_u32(binary->LHS())) { + // kConstantValue < index + // If `kConstantValue` is the highest possible value then the expression is + // always false. + auto* constant_value = binary->LHS()->As()->Value(); + if (constant_value->Type()->Is()) { + return constant_value->ValueAs() < i32::kHighestValue; + } + TINT_ASSERT(constant_value->Type()->Is()); + return constant_value->ValueAs() < u32::kHighestValue; + } + return false; + } case BinaryOp::kGreaterThan: { - return (is_index(binary->LHS()) && is_immutable_before_body(binary->RHS())) || - (is_index(binary->RHS()) && is_immutable_before_body(binary->LHS())); + if (is_index(binary->LHS()) && is_constant_i32_or_u32(binary->RHS())) { + // index > kConstantValue + // If `kConstantValue` is the highest possible value then the expression is + // always false. + auto* constant_value = binary->RHS()->As()->Value(); + if (constant_value->Type()->Is()) { + return constant_value->ValueAs() < i32::kHighestValue; + } + TINT_ASSERT(constant_value->Type()->Is()); + return constant_value->ValueAs() < u32::kHighestValue; + } else if (is_index(binary->RHS()) && is_constant_i32_or_u32(binary->LHS())) { + // kConstantValue > index + // If `kConstantValue` is the lowest possible value then the expression is + // always false. + auto* constant_value = binary->LHS()->As()->Value(); + if (constant_value->Type()->Is()) { + return constant_value->ValueAs() > i32::kLowestValue; + } + TINT_ASSERT(constant_value->Type()->Is()); + return constant_value->ValueAs() > u32::kLowestValue; + } + return false; } case BinaryOp::kLessThanEqual: { if (is_index(binary->LHS()) && is_constant_i32_or_u32(binary->RHS())) { diff --git a/3rdparty/dawn/src/tint/lang/core/ir/bitcast.h b/3rdparty/dawn/src/tint/lang/core/ir/bitcast.h deleted file mode 100644 index f75d007a8..000000000 --- a/3rdparty/dawn/src/tint/lang/core/ir/bitcast.h +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright 2023 The Dawn & Tint Authors -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// -// 3. Neither the name of the copyright holder nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef SRC_TINT_LANG_CORE_IR_BITCAST_H_ -#define SRC_TINT_LANG_CORE_IR_BITCAST_H_ - -#include - -#include "src/tint/lang/core/ir/call.h" -#include "src/tint/utils/rtti/castable.h" - -namespace tint::core::ir { - -/// A bitcast instruction in the IR. -class Bitcast final : public Castable { - public: - /// The offset in Operands() for the value - static constexpr size_t kValueOperandOffset = 0; - - /// The fixed number of results returned by this instruction - static constexpr size_t kNumResults = 1; - - /// The fixed number of operands expected for this instruction - static constexpr size_t kNumOperands = 1; - - /// Constructor (no results, no operands) - /// @param id the instruction id - explicit Bitcast(Id id); - - /// Constructor - /// @param id the instruction id - /// @param result the result value - /// @param val the value being bitcast - Bitcast(Id id, InstructionResult* result, Value* val); - - ~Bitcast() override; - - /// @copydoc Instruction::Clone() - Bitcast* Clone(CloneContext& ctx) override; - - /// @returns the operand value - Value* Val() { return Operand(kValueOperandOffset); } - - /// @returns the operand value - const Value* Val() const { return Operand(kValueOperandOffset); } - - /// @returns the friendly name for the instruction - std::string FriendlyName() const override { return "bitcast"; } - - /// @returns an empty access as the bitcast neither loads nor stores. - Accesses GetSideEffects() const override { return Accesses{}; } -}; - -} // namespace tint::core::ir - -#endif // SRC_TINT_LANG_CORE_IR_BITCAST_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/break_if.cc b/3rdparty/dawn/src/tint/lang/core/ir/break_if.cc index 9ab1be773..48d7a37bf 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/break_if.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/break_if.cc @@ -66,7 +66,7 @@ void BreakIf::Destroy() { if (loop_) { loop_->Body()->RemoveInboundSiblingBranch(this); } - Instruction::Destroy(); + Base::Destroy(); } BreakIf* BreakIf::Clone(CloneContext& ctx) { diff --git a/3rdparty/dawn/src/tint/lang/core/ir/builder.h b/3rdparty/dawn/src/tint/lang/core/ir/builder.h index eeef07293..e1809d8f6 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/builder.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/builder.h @@ -33,9 +33,9 @@ #include "src/tint/lang/core/constant/scalar.h" // IWYU pragma: export #include "src/tint/lang/core/constant/splat.h" // IWYU pragma: export #include "src/tint/lang/core/ir/access.h" -#include "src/tint/lang/core/ir/bitcast.h" #include "src/tint/lang/core/ir/block_param.h" #include "src/tint/lang/core/ir/break_if.h" +#include "src/tint/lang/core/ir/builtin_call.h" #include "src/tint/lang/core/ir/constant.h" #include "src/tint/lang/core/ir/constexpr_if.h" #include "src/tint/lang/core/ir/construct.h" @@ -584,10 +584,10 @@ class Builder { } template - auto Values(tint::Slice&&) { + auto Values(std::span&&) { static_assert(sizeof(T) != sizeof(T), // Condition must be type-dependent - "Cannot construct a Vector from a Slice as the size is not known at " - "compile-time. Use ToVector(Slice&&) instead."); + "Cannot construct a Vector from a span as the size is not known at " + "compile-time. Use ToVector(span&&) instead."); } /// Overload for Values() with tint::Empty argument @@ -666,12 +666,13 @@ class Builder { return Append(ir.CreateInstruction(result, op, lhs_val, rhs_val)); } - /// Creates an And operation + /// Creates Binary operation + /// @parm op the operator /// @param lhs the lhs of the add /// @param rhs the rhs of the add /// @returns the operation template - ir::CoreBinary* And(LHS&& lhs, RHS&& rhs) { + ir::CoreBinary* BinaryWithLHSType(BinaryOp op, LHS&& lhs, RHS&& rhs) { CheckForNonDeterministicEvaluation(); auto* lhs_value = Value(std::forward(lhs)); auto* rhs_value = Value(std::forward(rhs)); @@ -679,8 +680,17 @@ class Builder { TINT_ASSERT(rhs_value); TINT_ASSERT(lhs_value->Type() == rhs_value->Type()); - return Append(ir.CreateInstruction(InstructionResult(lhs_value->Type()), - BinaryOp::kAnd, lhs_value, rhs_value)); + return Append(ir.CreateInstruction(InstructionResult(lhs_value->Type()), op, + lhs_value, rhs_value)); + } + + /// Creates an And operation + /// @param lhs the lhs of the add + /// @param rhs the rhs of the add + /// @returns the operation + template + ir::CoreBinary* And(LHS&& lhs, RHS&& rhs) { + return BinaryWithLHSType(BinaryOp::kAnd, std::forward(lhs), std::forward(rhs)); } /// Creates an Or operation @@ -689,15 +699,7 @@ class Builder { /// @returns the operation template ir::CoreBinary* Or(LHS&& lhs, RHS&& rhs) { - CheckForNonDeterministicEvaluation(); - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - TINT_ASSERT(lhs_value->Type() == rhs_value->Type()); - - return Append(ir.CreateInstruction(InstructionResult(lhs_value->Type()), - BinaryOp::kOr, lhs_value, rhs_value)); + return BinaryWithLHSType(BinaryOp::kOr, std::forward(lhs), std::forward(rhs)); } /// Creates an Xor operation @@ -706,15 +708,24 @@ class Builder { /// @returns the operation template ir::CoreBinary* Xor(LHS&& lhs, RHS&& rhs) { + return BinaryWithLHSType(BinaryOp::kXor, std::forward(lhs), std::forward(rhs)); + } + + /// Creates a Binary op + /// @param op the operator + /// @param lhs the lhs of the add + /// @param rhs the rhs of the add + /// @returns the operation + template + ir::CoreBinary* BinaryWithBoolType(BinaryOp op, LHS&& lhs, RHS&& rhs) { CheckForNonDeterministicEvaluation(); auto* lhs_value = Value(std::forward(lhs)); auto* rhs_value = Value(std::forward(rhs)); TINT_ASSERT(lhs_value); TINT_ASSERT(rhs_value); - TINT_ASSERT(lhs_value->Type() == rhs_value->Type()); - - return Append(ir.CreateInstruction(InstructionResult(lhs_value->Type()), - BinaryOp::kXor, lhs_value, rhs_value)); + auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); + return Append(ir.CreateInstruction(InstructionResult(type), op, lhs_value, + rhs_value)); } /// Creates an Equal operation @@ -723,13 +734,7 @@ class Builder { /// @returns the operation template ir::CoreBinary* Equal(LHS&& lhs, RHS&& rhs) { - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); - return Append(ir.CreateInstruction(InstructionResult(type), - BinaryOp::kEqual, lhs_value, rhs_value)); + return BinaryWithBoolType(BinaryOp::kEqual, std::forward(lhs), std::forward(rhs)); } /// Creates an NotEqual operation @@ -738,13 +743,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* NotEqual(LHS&& lhs, RHS&& rhs) { - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); - return Append(ir.CreateInstruction( - InstructionResult(type), BinaryOp::kNotEqual, lhs_value, rhs_value)); + return BinaryWithBoolType(BinaryOp::kNotEqual, std::forward(lhs), + std::forward(rhs)); } /// Creates an LessThan operation @@ -753,13 +753,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* LessThan(LHS&& lhs, RHS&& rhs) { - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); - return Append(ir.CreateInstruction( - InstructionResult(type), BinaryOp::kLessThan, lhs_value, rhs_value)); + return BinaryWithBoolType(BinaryOp::kLessThan, std::forward(lhs), + std::forward(rhs)); } /// Creates an LessThan operation @@ -768,13 +763,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* GreaterThan(LHS&& lhs, RHS&& rhs) { - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); - return Append(ir.CreateInstruction( - InstructionResult(type), BinaryOp::kGreaterThan, lhs_value, rhs_value)); + return BinaryWithBoolType(BinaryOp::kGreaterThan, std::forward(lhs), + std::forward(rhs)); } /// Creates an LessThanEqual operation @@ -783,13 +773,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* LessThanEqual(LHS&& lhs, RHS&& rhs) { - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); - return Append(ir.CreateInstruction( - InstructionResult(type), BinaryOp::kLessThanEqual, lhs_value, rhs_value)); + return BinaryWithBoolType(BinaryOp::kLessThanEqual, std::forward(lhs), + std::forward(rhs)); } /// Creates an GreaterThanEqual operation @@ -798,13 +783,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* GreaterThanEqual(LHS&& lhs, RHS&& rhs) { - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - auto* type = ir.Types().MatchWidth(ir.Types().bool_(), lhs_value->Type()); - return Append(ir.CreateInstruction( - InstructionResult(type), BinaryOp::kGreaterThanEqual, lhs_value, rhs_value)); + return BinaryWithBoolType(BinaryOp::kGreaterThanEqual, std::forward(lhs), + std::forward(rhs)); } /// Creates an ShiftLeft operation @@ -837,12 +817,12 @@ class Builder { InstructionResult(lhs_value->Type()), BinaryOp::kShiftRight, lhs_value, rhs_value)); } - /// Creates an Add operation + /// Creates a binary expression with a computed type /// @param lhs the lhs of the add /// @param rhs the rhs of the add /// @returns the operation template - ir::CoreBinary* Add(LHS&& lhs, RHS&& rhs) { + ir::CoreBinary* BinaryWithComputedType(BinaryOp op, LHS&& lhs, RHS&& rhs) { CheckForNonDeterministicEvaluation(); auto* lhs_value = Value(std::forward(lhs)); auto* rhs_value = Value(std::forward(rhs)); @@ -865,8 +845,18 @@ class Builder { result_type = lhs_type; } - return Append(ir.CreateInstruction(InstructionResult(result_type), - BinaryOp::kAdd, lhs_value, rhs_value)); + return Append(ir.CreateInstruction(InstructionResult(result_type), op, + lhs_value, rhs_value)); + } + + /// Creates an Add operation + /// @param lhs the lhs of the add + /// @param rhs the rhs of the add + /// @returns the operation + template + ir::CoreBinary* Add(LHS&& lhs, RHS&& rhs) { + return BinaryWithComputedType(BinaryOp::kAdd, std::forward(lhs), + std::forward(rhs)); } /// Creates an Add operation @@ -886,30 +876,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* Subtract(LHS&& lhs, RHS&& rhs) { - CheckForNonDeterministicEvaluation(); - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - - auto* lhs_type = lhs_value->Type(); - auto* rhs_type = rhs_value->Type(); - - const core::type::Type* result_type = nullptr; - if (lhs_type->template Is()) { - result_type = lhs_type; - } else if (rhs_type->template Is()) { - result_type = rhs_type; - } else if (lhs_type->template Is()) { - result_type = lhs_type; - } else if (rhs_type->template Is()) { - result_type = rhs_type; - } else { - result_type = lhs_type; - } - - return Append(ir.CreateInstruction( - InstructionResult(result_type), BinaryOp::kSubtract, lhs_value, rhs_value)); + return BinaryWithComputedType(BinaryOp::kSubtract, std::forward(lhs), + std::forward(rhs)); } /// Creates an Multiply operation @@ -964,30 +932,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* Divide(LHS&& lhs, RHS&& rhs) { - CheckForNonDeterministicEvaluation(); - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - - auto* lhs_type = lhs_value->Type(); - auto* rhs_type = rhs_value->Type(); - - const core::type::Type* result_type = nullptr; - if (lhs_type->template Is()) { - result_type = lhs_type; - } else if (rhs_type->template Is()) { - result_type = rhs_type; - } else if (lhs_type->template Is()) { - result_type = lhs_type; - } else if (rhs_type->template Is()) { - result_type = rhs_type; - } else { - result_type = lhs_type; - } - - return Append(ir.CreateInstruction( - InstructionResult(result_type), BinaryOp::kDivide, lhs_value, rhs_value)); + return BinaryWithComputedType(BinaryOp::kDivide, std::forward(lhs), + std::forward(rhs)); } /// Creates an Modulo operation @@ -996,30 +942,8 @@ class Builder { /// @returns the operation template ir::CoreBinary* Modulo(LHS&& lhs, RHS&& rhs) { - CheckForNonDeterministicEvaluation(); - auto* lhs_value = Value(std::forward(lhs)); - auto* rhs_value = Value(std::forward(rhs)); - TINT_ASSERT(lhs_value); - TINT_ASSERT(rhs_value); - - auto* lhs_type = lhs_value->Type(); - auto* rhs_type = rhs_value->Type(); - - const core::type::Type* result_type = nullptr; - if (lhs_type->template Is()) { - result_type = lhs_type; - } else if (rhs_type->template Is()) { - result_type = rhs_type; - } else if (lhs_type->template Is()) { - result_type = lhs_type; - } else if (rhs_type->template Is()) { - result_type = rhs_type; - } else { - result_type = lhs_type; - } - - return Append(ir.CreateInstruction( - InstructionResult(result_type), BinaryOp::kModulo, lhs_value, rhs_value)); + return BinaryWithComputedType(BinaryOp::kModulo, std::forward(lhs), + std::forward(rhs)); } /// Creates a Min operation @@ -1114,9 +1038,10 @@ class Builder { /// @param val the value being bitcast /// @returns the instruction template - ir::Bitcast* Bitcast(const core::type::Type* type, VAL&& val) { - auto* value = Value(std::forward(val)); - return Append(ir.CreateInstruction(InstructionResult(type), value)); + ir::CoreBuiltinCall* Bitcast(const core::type::Type* type, VAL&& val) { + return CallExplicit(type, core::BuiltinFn::kBitcast, + Vector{type}, + Vector{Value(std::forward(val))}); } /// Creates a bitcast instruction @@ -1124,7 +1049,7 @@ class Builder { /// @param val the value being bitcast /// @returns the instruction template - ir::Bitcast* Bitcast(VAL&& val) { + ir::CoreBuiltinCall* Bitcast(VAL&& val) { auto* type = ir.Types().Get(); auto* value = Value(std::forward(val)); return Bitcast(type, value); @@ -1135,8 +1060,11 @@ class Builder { /// @param val the value being bitcast /// @returns the instruction template - ir::Bitcast* BitcastWithResult(ir::InstructionResult* result, VAL&& val) { - return Append(ir.CreateInstruction(result, val)); + ir::CoreBuiltinCall* BitcastWithResult(ir::InstructionResult* result, VAL&& val) { + return CallExplicitWithResult( + result, core::BuiltinFn::kBitcast, + Vector{result->Type()}, + Vector{Value(std::forward(val))}); } /// Creates a discard instruction @@ -1230,7 +1158,7 @@ class Builder { requires(tint::traits::IsTypeOrDerived) KLASS* CallExplicitWithResult(ir::InstructionResult* result, FUNC func, - VectorRef explicit_params, + VectorRef explicit_params, ARGS&&... args) { auto* inst = ir.CreateInstruction(result, func, Values(std::forward(args)...)); inst->SetExplicitTemplateParams(explicit_params); @@ -1259,7 +1187,7 @@ class Builder { requires(tint::traits::IsTypeOrDerived) KLASS* CallExplicit(const core::type::Type* type, FUNC func, - VectorRef explicit_params, + VectorRef explicit_params, ARGS&&... args) { return CallExplicitWithResult(InstructionResult(type), func, explicit_params, Values(std::forward(args)...)); @@ -1274,7 +1202,7 @@ class Builder { template ir::CoreBuiltinCall* CallExplicit(const core::type::Type* type, core::BuiltinFn func, - VectorRef explicit_params, + VectorRef explicit_params, ARGS&&... args) { return CallExplicitWithResult( InstructionResult(type), func, explicit_params, Values(std::forward(args)...)); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/call.h b/3rdparty/dawn/src/tint/lang/core/ir/call.h index a501f5236..3a235369e 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/call.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/call.h @@ -28,14 +28,18 @@ #ifndef SRC_TINT_LANG_CORE_IR_CALL_H_ #define SRC_TINT_LANG_CORE_IR_CALL_H_ +#include #include +#include "src/tint/lang/core/intrinsic/table.h" #include "src/tint/lang/core/ir/operand_instruction.h" #include "src/tint/lang/core/type/type.h" #include "src/tint/utils/rtti/castable.h" namespace tint::core::ir { +using TemplateParameter = core::intrinsic::TemplateParameter; + /// A Call instruction in the IR. class Call : public Castable> { public: @@ -45,20 +49,21 @@ class Call : public Castable> { virtual size_t ArgsOperandOffset() const { return 0; } /// Sets the explicit template params for the call - void SetExplicitTemplateParams(VectorRef params) { + void SetExplicitTemplateParams(VectorRef params) { explicit_template_params_ = params; } + /// Retrieves the explicit template params for the call - tint::VectorRef ExplicitTemplateParams() const { + tint::VectorRef ExplicitTemplateParams() const { return explicit_template_params_; } /// @returns the call arguments - tint::Slice Args() { return operands_.Slice().Offset(ArgsOperandOffset()); } + std::span Args() { return operands_.AsSpan().subspan(ArgsOperandOffset()); } /// @returns the call arguments - tint::Slice Args() const { - return operands_.Slice().Offset(ArgsOperandOffset()); + std::span Args() const { + return operands_.AsSpan().subspan(ArgsOperandOffset()); } /// Sets the argument at `idx` of `arg`. `idx` must be within bounds of the current argument @@ -76,7 +81,7 @@ class Call : public Castable> { /// Constructor explicit Call(Id id); - Vector explicit_template_params_; + Vector explicit_template_params_; }; } // namespace tint::core::ir diff --git a/3rdparty/dawn/src/tint/lang/core/ir/capabilities.h b/3rdparty/dawn/src/tint/lang/core/ir/capabilities.h new file mode 100644 index 000000000..6a994ff52 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/capabilities.h @@ -0,0 +1,54 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_CORE_IR_CAPABILITIES_H_ +#define SRC_TINT_LANG_CORE_IR_CAPABILITIES_H_ + +#include "src/tint/utils/containers/enum_set.h" + +namespace tint::core::ir { + +/// Enumerator of optional IR capabilities. +/// TODO(crbug.com/512904070): Remove this when transition to properties is complete. +enum class Capability : uint8_t { + /// Allows 16-bit integer types. + kAllow16BitIntegers, + /// Allows 64-bit integer types. + kAllow64BitIntegers, + /// Allows ShaderIO specific features, like blend_src on non-struct members. + /// These are not separate capabilities, because they are enabled/disabled in lockstep with each + /// other. + /// TODO(448417342): Validate in/out address space usage based on this capability + kLoosenValidationForShaderIO, +}; + +/// Capabilities is a set of Capability +using Capabilities = EnumSet; + +} // namespace tint::core::ir + +#endif // SRC_TINT_LANG_CORE_IR_CAPABILITIES_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/clone_context.h b/3rdparty/dawn/src/tint/lang/core/ir/clone_context.h index ea49f6ac3..6def91115 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/clone_context.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/clone_context.h @@ -28,6 +28,8 @@ #ifndef SRC_TINT_LANG_CORE_IR_CLONE_CONTEXT_H_ #define SRC_TINT_LANG_CORE_IR_CLONE_CONTEXT_H_ +#include + #include "src/tint/utils/containers/hashmap.h" #include "src/tint/utils/containers/transform.h" #include "src/tint/utils/rtti/traits.h" @@ -67,7 +69,7 @@ class CloneContext { /// @param what the elements to clone /// @return the cloned elements template - Vector Clone(Slice what) { + Vector Clone(std::span what) { return Transform(what, [&](T* const p) { return Clone(p); }); } @@ -75,7 +77,7 @@ class CloneContext { /// @param what the elements to clone /// @return the cloned elements template - Vector Clone(Slice what) { + Vector Clone(std::span what) { return Transform(what, [&](T* p) { return Clone(p); }); } @@ -102,7 +104,7 @@ class CloneContext { /// @param what the item /// @return the remapped elements template - Vector Remap(Slice what) { + Vector Remap(std::span what) { return Transform(what, [&](T* const p) { return Remap(p); }); } @@ -110,7 +112,7 @@ class CloneContext { /// @param what the item /// @return the remapped elements template - Vector Remap(Slice what) { + Vector Remap(std::span what) { return Transform(what, [&](T* p) { return Remap(p); }); } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/const_param_validator.cc b/3rdparty/dawn/src/tint/lang/core/ir/const_param_validator.cc index b71f9a74f..2bda243bb 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/const_param_validator.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/const_param_validator.cc @@ -28,6 +28,7 @@ #include "src/tint/lang/core/ir/const_param_validator.h" #include +#include #include #include @@ -38,11 +39,16 @@ #include "src/tint/lang/core/ir/core_builtin_call.h" #include "src/tint/lang/core/ir/instruction.h" #include "src/tint/lang/core/ir/instruction_result.h" +#include "src/tint/lang/core/ir/let.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/switch.h" #include "src/tint/lang/core/ir/type/array_count.h" +#include "src/tint/lang/core/ir/user_call.h" #include "src/tint/lang/core/ir/value.h" +#include "src/tint/lang/core/ir/var.h" #include "src/tint/lang/core/number.h" +#include "src/tint/lang/core/type/array.h" +#include "src/tint/lang/core/type/buffer.h" #include "src/tint/lang/core/type/type.h" #include "src/tint/utils/diagnostic/diagnostic.h" #include "src/tint/utils/internal_limits.h" @@ -78,6 +84,7 @@ class ConstParamValidator { void CheckSmoothstepCall(const CoreBuiltinCall* call); void CheckBinaryDivModCall(const CoreBinary* call); void CheckBinaryShiftCall(const CoreBinary* call); + void CheckBuffers(const Var* var, uint32_t input_size); diag::Diagnostic& AddError(const Instruction& inst); @@ -98,7 +105,7 @@ diag::Diagnostic& ConstParamValidator::AddError(const Instruction& inst) { } const constant::Value* GetConstArg(const CoreBuiltinCall* call, uint32_t param_index) { - if (call->Args().Length() <= param_index) { + if (call->Args().size() <= param_index) { return nullptr; } if (call->Args()[param_index] == nullptr) { @@ -290,6 +297,156 @@ void ConstParamValidator::CheckCoreBinaryCall(const CoreBinary* call) { } } +void ConstParamValidator::CheckBuffers(const Var* var, uint32_t input_size) { + Vector, 4> uses; + for (auto& u : var->Result()->UsagesSorted()) { + uses.Push(std::make_pair(u, input_size)); + } + while (!uses.IsEmpty()) { + auto [use, buffer_size] = uses.Pop(); + diag::Diagnostic error; + bool errored = tint::Switch( + use.instruction, + [&](const Let* let) { + for (auto& u : let->Result()->UsagesSorted()) { + uses.Push(std::make_pair(u, buffer_size)); + } + return false; + }, + [&](const UserCall* user) { + // If the buffer size is decreased at a function boundary, use that size + // instead. + auto* target = user->Target(); + auto* param = target->Params()[use.operand_index - user->ArgsOperandOffset()]; + auto* param_buffer_ty = param->Type()->UnwrapPtr()->As(); + uint32_t next_size = + param_buffer_ty->Size() > 0 ? param_buffer_ty->Size() : buffer_size; + for (auto& u : param->UsagesSorted()) { + uses.Push(std::make_pair(u, next_size)); + } + return false; + }, + [&](const CoreBuiltinCall* call) { + if (call->Func() != BuiltinFn::kBufferView && + call->Func() != BuiltinFn::kBufferArrayView) { + return false; + } + + // Calculate the minimum type size. + auto* store_ty = call->Result()->Type()->UnwrapPtr(); + uint64_t ty_required_size = 0; + uint64_t ty_offset = 0; + uint64_t ty_stride = 0; + if (store_ty->HasFixedFootprint()) { + ty_required_size = store_ty->Size(); + } else if (auto* str = store_ty->As()) { + auto* last = str->Members().Back(); + auto* arr_ty = last->Type()->As(); + ty_offset = last->Offset(); + ty_stride = arr_ty->ImplicitStride(); + ty_required_size = ty_offset + ty_stride; + } else { + ty_stride = store_ty->As()->ImplicitStride(); + ty_required_size = ty_stride; + } + + // Error conditions: + // For both bufferView and bufferArrayView: + // * ty_required_size + offset < buffer_size + // * offset % store_ty->Align() != 0 + // For bufferArrayView + // * size + offset < buffer_size + // * size < ty_required_size + // * (size - offset) % stride != 0 + // + // Also error if any addition overflows a uint32_t. + + uint64_t offset_val = 0; + if (auto* const_offset = call->Args()[1]->As()) { + if (const_offset->Type()->IsSignedIntegerScalar()) { + if (const_offset->Value()->ValueAs() < 0) { + AddError(*call) + << call->FriendlyName() << " offset must be greater than 0"; + return true; + } + } + offset_val = const_offset->Value()->ValueAs(); + } + + if (offset_val + ty_required_size > std::numeric_limits::max()) { + AddError(*call) << call->FriendlyName() << " requires a size beyond 32 bits"; + return true; + } + + if (buffer_size > 0 && buffer_size < offset_val + ty_required_size) { + AddError(*var) << "invalid buffer size (" << buffer_size + << " bytes) when used with " << call->FriendlyName() << " (" + << offset_val + ty_required_size << " bytes required)"; + return true; + } + + if (offset_val % store_ty->Align() != 0) { + AddError(*call) << call->FriendlyName() << " offset (" << offset_val + << " bytes) must be a multiple of result alignment (" + << store_ty->Align() << " bytes)"; + return true; + } + + if (call->Func() == BuiltinFn::kBufferView) { + return false; + } + + uint64_t size_val = 0; + if (auto* const_size = call->Args()[2]->As()) { + if (const_size->Type()->IsSignedIntegerScalar()) { + if (const_size->Value()->ValueAs() < 0) { + AddError(*call) + << call->FriendlyName() << " size must be greater than 0"; + return true; + } + } + size_val = const_size->Value()->ValueAs(); + if (size_val == 0) { + AddError(*call) << call->FriendlyName() << " cannot be 0 sized"; + return true; + } + } + + if (offset_val + size_val > std::numeric_limits::max()) { + AddError(*call) << call->FriendlyName() << " requires a size beyond 32 bits"; + return true; + } + + if (buffer_size > 0 && buffer_size < size_val + offset_val) { + AddError(*var) << "invalid buffer size (" << buffer_size + << " bytes) when used with " << call->FriendlyName() << " (" + << size_val + offset_val << " bytes required)"; + return true; + } + + if (size_val > 0 && size_val < ty_required_size) { + AddError(*call) << call->FriendlyName() << " has invalid size (" << size_val + << " bytes, requires " << ty_required_size << " bytes)"; + return true; + } + + if (size_val > 0 && ((size_val - ty_offset) % ty_stride != 0)) { + AddError(*call) << call->FriendlyName() << " size (" << size_val + << " bytes) minus type offset (" << ty_offset + << " bytes) must be a multiple of the type stride (" + << ty_stride << " bytes)"; + return true; + } + + return false; + }, + [&](Default) { return false; }); + if (errored) { + return; + } + } +} + Result ConstParamValidator::Run() { auto instructions = this->mod_.Instructions(); @@ -301,6 +458,18 @@ Result ConstParamValidator::Run() { [&](Default) {}); } + for (auto* inst : *this->mod_.root_block) { + if (auto* var = inst->As()) { + auto* buffer_ty = var->Result()->Type()->UnwrapPtr()->As(); + if (!buffer_ty) { + continue; + } + + uint32_t size = buffer_ty->Size(); + CheckBuffers(var, size); + } + } + if (diagnostics_.ContainsErrors()) { return Failure{diagnostics_.Str()}; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/continue.cc b/3rdparty/dawn/src/tint/lang/core/ir/continue.cc index ae3229956..c35131bc2 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/continue.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/continue.cc @@ -58,7 +58,7 @@ void Continue::Destroy() { if (loop_) { loop_->Continuing()->RemoveInboundSiblingBranch(this); } - Instruction::Destroy(); + Base::Destroy(); } Continue* Continue::Clone(CloneContext& ctx) { diff --git a/3rdparty/dawn/src/tint/lang/core/ir/core_builtin_call.cc b/3rdparty/dawn/src/tint/lang/core/ir/core_builtin_call.cc index e56be6108..1f2b73eca 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/core_builtin_call.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/core_builtin_call.cc @@ -52,7 +52,9 @@ CoreBuiltinCall::~CoreBuiltinCall() = default; CoreBuiltinCall* CoreBuiltinCall::Clone(CloneContext& ctx) { auto* new_result = ctx.Clone(Result()); auto args = ctx.Remap(Args()); - return ctx.ir.CreateInstruction(new_result, func_, args); + auto* cloned = ctx.ir.CreateInstruction(new_result, func_, args); + cloned->SetExplicitTemplateParams(ExplicitTemplateParams()); + return cloned; } tint::core::ir::Instruction::Accesses CoreBuiltinCall::GetSideEffects() const { @@ -130,6 +132,7 @@ tint::core::ir::Instruction::Accesses CoreBuiltinCall::GetSideEffects() const { case BuiltinFn::kAbs: case BuiltinFn::kAcos: case BuiltinFn::kAcosh: + case BuiltinFn::kAddSat: case BuiltinFn::kAll: case BuiltinFn::kAny: case BuiltinFn::kArrayLength: @@ -138,6 +141,7 @@ tint::core::ir::Instruction::Accesses CoreBuiltinCall::GetSideEffects() const { case BuiltinFn::kAtan: case BuiltinFn::kAtan2: case BuiltinFn::kAtanh: + case BuiltinFn::kBitcast: case BuiltinFn::kCeil: case BuiltinFn::kClamp: case BuiltinFn::kCos: @@ -222,6 +226,7 @@ tint::core::ir::Instruction::Accesses CoreBuiltinCall::GetSideEffects() const { case BuiltinFn::kHasResource: case BuiltinFn::kBufferView: case BuiltinFn::kBufferLength: + case BuiltinFn::kBufferArrayView: case BuiltinFn::kNone: break; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/disassembler.cc b/3rdparty/dawn/src/tint/lang/core/ir/disassembler.cc index 84ffdd85c..33f0066db 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/disassembler.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/disassembler.cc @@ -37,6 +37,7 @@ #include "src/tint/lang/core/constant/scalar.h" #include "src/tint/lang/core/constant/splat.h" #include "src/tint/lang/core/constant/string.h" +#include "src/tint/lang/core/intrinsic/table.h" #include "src/tint/lang/core/ir/binary.h" #include "src/tint/lang/core/ir/block.h" #include "src/tint/lang/core/ir/block_param.h" @@ -110,6 +111,19 @@ class ScopedIndent { } // namespace +// Static +std::string Disassembler::Disassemble(const Module& mod, const Instruction* inst) { + if (!inst) { + return "undef"; + } + Disassembler d(mod); + d.out_.Clear(); + d.current_output_line_ = 1; + d.current_output_start_pos_ = 0; + d.EmitInstruction(inst); + return std::string(TrimSuffix(d.Plain(), "\n")); +} + Disassembler::Disassembler(Disassembler&&) = default; Disassembler::Disassembler(const Module& mod) : mod_(mod) { @@ -543,7 +557,7 @@ void Disassembler::EmitInstruction(const Instruction* inst) { if (i > 0) { out_ << ", "; } - out_ << ep[i]->FriendlyName(); + out_ << ep[i]; } out_ << ">"; } @@ -758,14 +772,26 @@ void Disassembler::EmitLoop(const Loop* l) { } out_ << StyleInstruction("loop") << " ["; - if (l->Initializer() != nullptr && !l->Initializer()->IsEmpty()) { + auto is_printable = [](const Block* b) { + if (b == nullptr) { + return false; + } + if (!b->IsEmpty()) { + return true; + } + + auto* mb = b->As(); + return (mb && !mb->Params().IsEmpty()); + }; + + if (is_printable(l->Initializer())) { out_ << StyleKeyword("i") << ": " << NameOf(l->Initializer()); out_ << ", "; } out_ << StyleKeyword("b") << ": " << NameOf(l->Body()); - if (l->Continuing() != nullptr && !l->Continuing()->IsEmpty()) { + if (is_printable(l->Continuing())) { out_ << ", "; out_ << StyleKeyword("c") << ": " << NameOf(l->Continuing()); } @@ -776,7 +802,7 @@ void Disassembler::EmitLoop(const Loop* l) { out_ << " { " << StyleComment("# ", NameOf(l)); EmitLine(); - if (l->Initializer() != nullptr && !l->Initializer()->IsEmpty()) { + if (is_printable(l->Initializer())) { ScopedIndent si(indent_size_); EmitBlock(l->Initializer(), "initializer"); } @@ -786,7 +812,7 @@ void Disassembler::EmitLoop(const Loop* l) { EmitBlock(l->Body(), "body"); } - if (l->Continuing() != nullptr && !l->Continuing()->IsEmpty()) { + if (is_printable(l->Continuing())) { ScopedIndent si(indent_size_); EmitBlock(l->Continuing(), "continuing"); } @@ -1036,6 +1062,9 @@ StyledText Disassembler::NameOf(const core::type::Type* ty) { const core::ir::type::ValueArrayCount* cnt) -> void { out << "array<" << ary->ElemType()->FriendlyName() << ", " << NameOf(cnt->value) << ">"; }; + auto buf_emit = [&](StyledText& out, const core::ir::type::ValueArrayCount* cnt) -> void { + out << "buffer<" << NameOf(cnt->value) << ">"; + }; if (auto* ptr = ty->As()) { if (auto* ary = ty->UnwrapPtr()->As()) { @@ -1047,6 +1076,18 @@ StyledText Disassembler::NameOf(const core::type::Type* ty) { ary_emit(out, ary, cnt); out << ", " << ptr->Access() << ">"; + return out; + } + } + if (auto* buf = ty->UnwrapPtr()->As()) { + if (auto* cnt = buf->Count()->As()) { + auto out = StyledText{} << "ptr<"; + if (ptr->AddressSpace() != core::AddressSpace::kUndefined) { + out << ptr->AddressSpace() << ", "; + } + buf_emit(out, cnt); + out << ", " << ptr->Access() << ">"; + return out; } } @@ -1056,6 +1097,12 @@ StyledText Disassembler::NameOf(const core::type::Type* ty) { ary_emit(out, ary, cnt); return out; } + } else if (auto* buf = ty->UnwrapPtr()->As()) { + if (auto* cnt = buf->Count()->As()) { + auto out = StyledText{}; + buf_emit(out, cnt); + return out; + } } return StyledText{} << StyleType(ty->FriendlyName()); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/disassembler.h b/3rdparty/dawn/src/tint/lang/core/ir/disassembler.h index cec6f41ce..65fd81a14 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/disassembler.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/disassembler.h @@ -73,6 +73,11 @@ class Disassembler { } }; + /// @param mod the module + /// @param inst the instruction to disassemble + /// @returns the disassembled instruction + static std::string Disassemble(const Module& mod, const Instruction* inst); + /// Constructor. /// Performs the disassembly of the module @p mod, constructing a Source::File with the name @p /// file_name. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/evaluator.cc b/3rdparty/dawn/src/tint/lang/core/ir/evaluator.cc index 36aad94ab..9e4b086ba 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/evaluator.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/evaluator.cc @@ -85,7 +85,6 @@ Evaluator::EvalResult Evaluator::EvalValue(core::ir::Value* val) { [&](core::ir::InstructionResult* r) { return tint::Switch( r->Instruction(), // - [&](core::ir::Bitcast* bc) { return EvalBitcast(bc); }, [&](core::ir::Access* a) { return EvalAccess(a); }, [&](core::ir::ConstExprIf* c) { return EvalConstExprIf(c); }, [&](core::ir::Construct* c) { return EvalConstruct(c); }, @@ -103,18 +102,6 @@ Evaluator::EvalResult Evaluator::EvalValue(core::ir::Value* val) { TINT_ICE_ON_NO_MATCH); } -Evaluator::EvalResult Evaluator::EvalBitcast(core::ir::Bitcast* bc) { - TINT_CHECK_RESULT_UNWRAP(val, EvalValue(bc->Val())); - // Check if the value could be evaluated - if (!val) { - return nullptr; - } - - TINT_CHECK_RESULT_UNWRAP(r, - const_eval_.bitcast(bc->Result()->Type(), Vector{val}, SourceOf(bc))); - return r; -} - Evaluator::EvalResult Evaluator::EvalAccess(core::ir::Access* a) { TINT_CHECK_RESULT_UNWRAP(obj, EvalValue(a->Object())); @@ -151,9 +138,9 @@ Evaluator::EvalResult Evaluator::EvalConstruct(core::ir::Construct* c) { auto result_ty = c->Result()->Type(); Vector arg_types; - arg_types.Reserve(c->Args().Length()); + arg_types.Reserve(c->Args().size()); Vector arg_values; - arg_values.Reserve(c->Args().Length()); + arg_values.Reserve(c->Args().size()); for (auto* arg : c->Args()) { arg_types.Push(arg->Type()); @@ -168,8 +155,8 @@ Evaluator::EvalResult Evaluator::EvalConstruct(core::ir::Construct* c) { auto mat_vec = [&](const core::type::Type* type, core::intrinsic::CtorConv intrinsic) -> constant::Eval::Result { - auto op = - table.Lookup(intrinsic, Vector{type}, arg_types, core::EvaluationStage::kOverride); + auto op = table.Lookup(intrinsic, Vector{type}, arg_types, + core::EvaluationStage::kOverride); if (op != Success) { AddError(SourceOf(c)) << "unable to find intrinsic for construct: " << op.Failure(); return Failure(); @@ -344,9 +331,9 @@ Evaluator::EvalResult Evaluator::EvalCoreBuiltinCall(core::ir::CoreBuiltinCall* intrinsic::Context context{c->TableData(), b_.ir.Types(), b_.ir.symbols}; Vector arg_types; - arg_types.Reserve(c->Args().Length()); + arg_types.Reserve(c->Args().size()); Vector args; - args.Reserve(c->Args().Length()); + args.Reserve(c->Args().size()); for (auto* arg : c->Args()) { arg_types.Push(arg->Type()); @@ -359,7 +346,8 @@ Evaluator::EvalResult Evaluator::EvalCoreBuiltinCall(core::ir::CoreBuiltinCall* } auto overload = core::intrinsic::LookupFn(context, c->FriendlyName().c_str(), c->FuncId(), - Empty, arg_types, core::EvaluationStage::kOverride); + c->ExplicitTemplateParams(), arg_types, + core::EvaluationStage::kOverride); if (overload != Success) { AddError(SourceOf(c)) << overload.Failure(); return Failure(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/evaluator.h b/3rdparty/dawn/src/tint/lang/core/ir/evaluator.h index e8fe27a32..9fcc81e7c 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/evaluator.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/evaluator.h @@ -61,7 +61,6 @@ class Evaluator { diag::Diagnostic& AddError(Source src); Source SourceOf(core::ir::Instruction* val); - EvalResult EvalBitcast(core::ir::Bitcast* bc); EvalResult EvalValue(core::ir::Value* val); EvalResult EvalAccess(core::ir::Access* a); EvalResult EvalConvert(core::ir::Convert* c); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/function.cc b/3rdparty/dawn/src/tint/lang/core/ir/function.cc index 61a90eb4e..3fabd4c10 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/function.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/function.cc @@ -56,7 +56,7 @@ Function* Function::Clone(CloneContext& ctx) { auto* new_func = ctx.ir.CreateValue(Type(), return_.type, pipeline_stage_, workgroup_size_); new_func->block_ = ctx.ir.blocks.Create(); - new_func->SetParams(ctx.Clone<1>(params_.Slice())); + new_func->SetParams(ctx.Clone<1>(params_.AsSpan())); new_func->return_.attributes = return_.attributes; ctx.Replace(this, new_func); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/functional_validator.cc b/3rdparty/dawn/src/tint/lang/core/ir/functional_validator.cc new file mode 100644 index 000000000..864a490f3 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/functional_validator.cc @@ -0,0 +1,1523 @@ +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/tint/lang/core/ir/functional_validator.h" + +#include + +#include "src/tint/lang/core/intrinsic/dialect.h" +#include "src/tint/lang/core/ir/discard.h" +#include "src/tint/lang/core/ir/exit_if.h" +#include "src/tint/lang/core/ir/exit_switch.h" +#include "src/tint/lang/core/ir/multi_in_block.h" +#include "src/tint/lang/core/ir/next_iteration.h" +#include "src/tint/lang/core/ir/phony.h" +#include "src/tint/lang/core/ir/terminate_invocation.h" +#include "src/tint/lang/core/ir/type/array_count.h" +#include "src/tint/lang/core/ir/unreachable.h" +#include "src/tint/lang/core/ir/unused.h" +#include "src/tint/lang/core/type/array.h" +#include "src/tint/lang/core/type/bool.h" +#include "src/tint/lang/core/type/f16.h" +#include "src/tint/lang/core/type/f32.h" +#include "src/tint/lang/core/type/i32.h" +#include "src/tint/lang/core/type/i8.h" +#include "src/tint/lang/core/type/matrix.h" +#include "src/tint/lang/core/type/memory_view.h" +#include "src/tint/lang/core/type/pointer.h" +#include "src/tint/lang/core/type/reference.h" +#include "src/tint/lang/core/type/u32.h" +#include "src/tint/lang/core/type/u64.h" +#include "src/tint/lang/core/type/u8.h" +#include "src/tint/lang/core/type/vector.h" +#include "src/tint/lang/core/type/void.h" +#include "src/tint/utils/containers/transform.h" +#include "src/tint/utils/rtti/switch.h" +#include "src/tint/utils/text/styled_text.h" + +namespace tint::core::ir::validator { +namespace { + +template +void WalkTypeAndMembers(CTX& ctx, + const core::type::Type* type, + const IOAttributes& attr, + IMPL&& impl); + +/// Helper that walks the members of a struct, called from WalkTypeAndMembers and its helpers +/// @param ctx a context object to pass to the impl function +/// @param str the struct to walk the members of +/// @param impl an impl function to be run, see WalkTypeAndMembers for details +template +void WalkStructMembers(CTX& ctx, const core::type::Struct* str, IMPL&& impl) { + for (auto* member : str->Members()) { + WalkTypeAndMembers(ctx, member->Type(), member->Attributes(), impl); + } +} + +/// Helper that walks an array's element type, called from WalkTypeAndMembers and its helpers +/// @param ctx a context object to pass to the impl function +/// @param arr the array to walk the element type of +/// @param impl an impl function to be run, see WalkTypeAndMembers for details +template +void WalkArrayElements(CTX& ctx, const core::type::Array* arr, IMPL&& impl) { + WalkTypeAndMembers(ctx, arr->ElemType(), IOAttributes{}, impl); +} + +/// Helper for walking a type that maybe a struct, calling an impl function for the type and each of +/// its members. +/// @param ctx a context object to pass to the implementation function +/// @param type the type to walk +/// @param attr the attributes for @p type +/// @param impl a function with the signature `void(const core::type::Type*, const IOAttributes&, +/// CTX&)` that is called for each type. +template +void WalkTypeAndMembers(CTX& ctx, + const core::type::Type* type, + const IOAttributes& attr, + IMPL&& impl) { + impl(ctx, type, attr); + tint::Switch( + type, [&](const core::type::Struct* s) { WalkStructMembers(ctx, s, impl); }, + [&](const core::type::Array* a) { WalkArrayElements(ctx, a, impl); }); +} + +/// @returns true if the type or any contained types are of type T +/// @param ty root of the types to walk +template +bool ContainsType(const core::type::Type* ty) { + bool found = false; + WalkTypeAndMembers(found, ty, IOAttributes{}, + [&](bool& ctx, const core::type::Type* t, const IOAttributes&) { + if (t != nullptr && t->DeepestElement()->Is()) { + ctx = true; + } + }); + return found; +} + +/// @returns the parent block of @p block +const Block* ParentBlockOf(const Block* block) { + if (auto* parent = block->Parent()) { + return parent->Block(); + } + return nullptr; +} + +/// @returns true if @p block directly or transitively holds the instruction @p inst +bool TransitivelyHolds(const Block* block, const Instruction* inst) { + for (auto* b = inst->Block(); b; b = ParentBlockOf(b)) { + if (b == block) { + return true; + } + } + return false; +} + +/// @returns true if @p ty meets the basic function parameter rules (i.e. one of constructible, +/// pointer, handle). +/// +/// Note: Does not handle corner cases like if certain properties are present. +bool IsValidFunctionParamType(const core::type::Type* ty) { + if (ty->IsConstructible() || ty->IsHandle()) { + return true; + } + + if (auto* ptr = ty->As()) { + return ptr->AddressSpace() != core::AddressSpace::kHandle; + } + return false; +} + +} // namespace + +Functional::Functional(const Module& ir, diag::List& diagnostics, ErrorSource error_source) + : ir_(ir), diag_(diagnostics), error_source_(error_source) {} + +Functional::~Functional() = default; + +void Functional::Validate() { + CheckRootBlock(ir_.root_block); + + for (const Function* func : ir_.functions) { + CheckFunction(func); + } +} + +Disassembler& Functional::Disassemble() { + TINT_ASSERT(error_source_ == ErrorSource::kIr); + + if (!disassembler_) { + disassembler_.emplace(ir::Disassembler(ir_)); + } + return *disassembler_; +} + +StyledText Functional::NameOf(const core::type::Type* ty) { + auto name = ty ? ty->FriendlyName() : "undef"; + return StyledText{} << style::Type(name); +} + +StyledText Functional::NameOf(const Value* value) { + if (error_source_ == ErrorSource::kWgsl) { + return StyledText{} << ir_.NameOf(value).to_str(); + } + return Disassemble().NameOf(value); +} + +Source Functional::SourceOf(const Function* func) { + if (error_source_ == ErrorSource::kWgsl) { + return ir_.SourceOf(func); + } + return Disassemble().FunctionSource(func); +} + +Source Functional::SourceOf(const FunctionParam* param) { + if (error_source_ == ErrorSource::kWgsl) { + return ir_.SourceOf(param); + } + return Disassemble().FunctionParamSource(param); +} + +Source Functional::SourceOf(const Instruction* inst) { + if (error_source_ == ErrorSource::kWgsl) { + return ir_.SourceOf(inst); + } + return Disassemble().InstructionSource(inst); +} + +Source Functional::SourceOf(const Instruction* inst, size_t idx) { + if (error_source_ == ErrorSource::kWgsl) { + return ir_.SourceOf(inst->Operands()[idx]); + } + return Disassemble().OperandSource( + Disassembler::IndexedValue{inst, static_cast(idx)}); +} + +diag::Diagnostic& Functional::AddError(Source src) { + auto& diag = diag_.AddError(src); + if (error_source_ == ErrorSource::kIr) { + diag.owned_file = Disassemble().File(); + } + return diag; +} + +diag::Diagnostic& Functional::AddError(const Function* func) { + return AddError(SourceOf(func)); +} + +diag::Diagnostic& Functional::AddError(const FunctionParam* param) { + return AddError(SourceOf(param)); +} + +diag::Diagnostic& Functional::AddError(const Instruction* inst) { + auto& diag = AddError(SourceOf(inst)); + if (error_source_ == ErrorSource::kWgsl) { + return diag; + } + + diag << inst->FriendlyName() << ": "; + if (!block_stack_.IsEmpty()) { + AddNote(block_stack_.Back()) << "in block"; + + // Adding the note may trigger a resize and invalidate the error diagnostic reference, + // so we need to get a new reference to the error diagnostic here. + return *(diag_.end() - 2); + } + return diag; +} + +diag::Diagnostic& Functional::AddError(const Instruction* inst, size_t idx) { + auto& diag = AddError(SourceOf(inst, idx)); + if (error_source_ == ErrorSource::kWgsl) { + return diag; + } + + diag << inst->FriendlyName() << ": "; + + if (!block_stack_.IsEmpty()) { + AddNote(block_stack_.Back()) << "in block"; + + // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we + // need to get a new reference to the error diagnostic here. + return *(diag_.end() - 2); + } + return diag; +} + +diag::Diagnostic& Functional::AddNote(Source src) { + auto& diag = diag_.AddNote(src); + if (error_source_ == ErrorSource::kIr) { + diag.owned_file = Disassemble().File(); + } + return diag; +} + +diag::Diagnostic& Functional::AddNote(const Block* blk) { + TINT_ASSERT(error_source_ == ErrorSource::kIr); + auto src = Disassemble().BlockSource(blk); + return AddNote(src); +} + +diag::Diagnostic& Functional::AddNote(const Instruction* inst) { + return AddNote(SourceOf(inst)); +} + +diag::Diagnostic& Functional::AddNote(const Instruction* inst, size_t idx) { + return AddNote(SourceOf(inst, idx)); +} + +void Functional::CheckRootBlock(const Block* blk) { + block_stack_.Push(blk); + TINT_DEFER({ + block_stack_.Pop(); + TINT_ASSERT(block_stack_.IsEmpty()); + }); + + for (auto* inst : *blk) { + CheckInstruction(inst); + } +} + +void Functional::CheckFunction(const Function* func) { + if (func->IsEntryPoint()) { + // Check that there is at most one entry point unless we allow multiple entry points. + if (!ir_.properties.Contains(Property::kAllowMultipleEntryPoints)) { + if (!entry_point_names_.IsEmpty()) { + AddError(func) << "a module with multiple entry points requires the " + "AllowMultipleEntryPoints property"; + return; + } + } + + if (DAWN_UNLIKELY(ir_.NameOf(func).Name().empty())) { + AddError(func) << "entry points must have names"; + } else { + // Checking the name early, so its usage can be recorded, even if the function is + // malformed. + const auto name = ir_.NameOf(func).Name(); + if (!entry_point_names_.Add(name)) { + AddError(func) << "entry point name " << style::Function(name) << " is not unique"; + } + } + + if (func->Stage() == Function::PipelineStage::kCompute) { + if (DAWN_UNLIKELY(!func->ReturnType()->Is())) { + AddError(func) << "compute entry point must not have a return type, found " + << NameOf(func->ReturnType()); + } + } + } + + // void needs to be filtered out, since it isn't constructible, but used in the IR when no + // return is specified. + if (DAWN_UNLIKELY(!func->ReturnType()->Is() && + !func->ReturnType()->IsConstructible())) { + AddError(func) << "function return type must be constructible"; + } + + for (auto* param : func->Params()) { + CheckFunctionParam(param); + } + + CheckBlock(func->Block()); +} + +void Functional::CheckFunctionParam(const FunctionParam* param) { + TINT_ASSERT(param->Function() != nullptr); + + bool func_is_entry_point = param->Function()->IsEntryPoint(); + + if (!IsValidFunctionParamType(param->Type())) { + auto ptr_ty = param->Type()->As(); + bool allowed_ptr_to_handle = ir_.properties.Contains(Property::kAllowPointerToHandle) && + ptr_ty != nullptr && ptr_ty->StoreType()->IsHandle(); + + auto struct_ty = param->Type()->As(); + if (!allowed_ptr_to_handle && + (!ir_.properties.Contains(Property::kAllowMslEntryPointInterface) || + (struct_ty == nullptr) || + struct_ty->Members().Any([](const core::type::StructMember* m) { + return !IsValidFunctionParamType(m->Type()); + }))) { + AddError(param) << "function parameter type, " << NameOf(param->Type()) + << ", must be constructible, a pointer, or a handle"; + } + } + + AddressSpace address_space = AddressSpace::kUndefined; + auto* mv = param->Type()->As(); + if (mv) { + address_space = mv->AddressSpace(); + } else { + // ModuleScopeVars transform in MSL backends unwraps pointers to handles + if (param->Type()->IsHandle()) { + address_space = AddressSpace::kHandle; + } + } + + if (address_space == AddressSpace::kPixelLocal) { + if (!mv->StoreType()->Is()) { + AddError(param) << "pixel_local param must be of type struct"; + } + } + + if (func_is_entry_point && !ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + if (param->Type()->Is()) { + AddError(param) << "entry point parameters cannot be pointers"; + } + + if (mv && mv->Is() && address_space == AddressSpace::kWorkgroup) { + AddError(param) << "input param to entry point cannot be a ptr in the 'workgroup' " + "address space"; + } + } +} + +void Functional::CheckBlock(const Block* blk) { + block_stack_.Push(blk); + TINT_DEFER({ block_stack_.Pop(); }); + + const Instruction* inst = blk->Instructions(); + while (inst != nullptr) { + CheckInstruction(inst); + inst = inst->next; + } +} + +void Functional::CheckInstruction(const Instruction* inst) { + tint::Switch( + inst, // + [&](const Access* a) { CheckAccess(a); }, // + [&](const Binary* b) { CheckBinary(b); }, // + [&](const Call* c) { CheckCall(c); }, // + [&](const If* if_) { CheckIf(if_); }, // + [&](const Let* l) { CheckLet(l); }, // + [&](const Load* load) { CheckLoad(load); }, // + [&](const LoadVectorElement* l) { CheckLoadVectorElement(l); }, // + [&](const Loop* l) { CheckLoop(l); }, // + [&](const Override* o) { CheckOverride(o); }, // + [&](const Phony*) {}, // + [&](const Store* s) { CheckStore(s); }, // + [&](const StoreVectorElement* s) { CheckStoreVectorElement(s); }, // + [&](const Switch* s) { CheckSwitch(s); }, // + [&](const Swizzle* s) { CheckSwizzle(s); }, // + [&](const Terminator* b) { CheckTerminator(b); }, // + [&](const Unary* u) { CheckUnary(u); }, // + [&](const Var* var) { CheckVar(var); }, // + TINT_ICE_ON_NO_MATCH); +} + +void Functional::CheckOverride(const Override* o) { + if (o->OverrideId().has_value()) { + if (!seen_override_ids_.Add(o->OverrideId().value())) { + AddError(o) << "duplicate override id encountered: " << o->OverrideId().value().value; + return; + } + } + + if (!o->Result()->Type()->IsScalar()) { + AddError(o) << "override type " << NameOf(o->Result()->Type()) << " is not a scalar"; + return; + } + + if (o->Initializer() && o->Initializer()->Type() != o->Result()->Type()) { + AddError(o) << "override type " << NameOf(o->Result()->Type()) + << " does not match initializer type " << NameOf(o->Initializer()->Type()); + return; + } + + if (!o->OverrideId().has_value() && (o->Initializer() == nullptr)) { + AddError(o) << "must have an id or an initializer"; + return; + } +} + +void Functional::CheckVar(const Var* var) { + auto* result_type = var->Result()->Type(); + auto* mv = result_type->As(); + if (!mv) { + AddError(var) << "result type " << NameOf(result_type) + << " must be a pointer or a reference"; + return; + } + + // Check that initializer and result type match + if (var->Initializer()) { + if (mv->AddressSpace() != AddressSpace::kFunction && + mv->AddressSpace() != AddressSpace::kPrivate && + mv->AddressSpace() != AddressSpace::kOut) { + AddError(var) << "only variables in the function, private, or __out address space may " + "be initialized"; + return; + } + + if (var->Initializer()->Type() != result_type->UnwrapPtrOrRef()) { + AddError(var) << "initializer type " << NameOf(var->Initializer()->Type()) + << " does not match store type " << NameOf(result_type->UnwrapPtrOrRef()); + return; + } + } + + if (var->Block() == ir_.root_block && mv->AddressSpace() == AddressSpace::kFunction) { + AddError(var) << "vars in the 'function' address space must be in a function scope"; + return; + } + if (var->Block() != ir_.root_block && mv->AddressSpace() != AddressSpace::kFunction) { + if (!ir_.properties.Contains(Property::kAllowMslEntryPointInterface) || + mv->AddressSpace() != AddressSpace::kPrivate) { + AddError(var) << "vars in a function scope must be in the 'function' address space"; + return; + } + } + + if (mv->AddressSpace() != AddressSpace::kStorage && + mv->AddressSpace() != AddressSpace::kHandle) { + if (mv->AddressSpace() == AddressSpace::kWorkgroup || + !ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + if (!mv->StoreType()->HasFixedFootprint()) { + AddError(var) << "vars not in the 'storage' or 'handle' address spaces " + "must have a fixed footprint"; + return; + } + } + } + + if (ContainsType(mv->StoreType())) { + bool is_workgroup = mv->AddressSpace() == AddressSpace::kWorkgroup; + bool is_read_write_storage = mv->AddressSpace() == AddressSpace::kStorage && + mv->Access() == core::Access::kReadWrite; + if (!is_workgroup && !is_read_write_storage) { + AddError(var) + << "atomic types may only be used by 'workspace' or read write 'storage' variables"; + return; + } + } + + if (var->InputAttachmentIndex().has_value()) { + if (mv->AddressSpace() != AddressSpace::kHandle) { + AddError(var) << "'@input_attachment_index' is not valid for non-handle var"; + return; + } + if (!ir_.properties.Contains(Property::kAllowAnyInputAttachmentIndexType) && + !mv->UnwrapPtrOrRef()->Is()) { + AddError(var) + << "'@input_attachment_index' is only valid for 'input_attachment' type var"; + return; + } + } + + if (mv->AddressSpace() == AddressSpace::kStorage) { + if (mv->StoreType() && !mv->StoreType()->IsHostShareable()) { + AddError(var) << "vars in the 'storage' address space must be host-shareable"; + return; + } + if (mv->Access() != core::Access::kReadWrite && mv->Access() != core::Access::kRead) { + AddError(var) + << "vars in the 'storage' address space must have access 'read' or 'read-write'"; + return; + } + } else if (mv->AddressSpace() == AddressSpace::kUniform) { + if (!(mv->StoreType()->IsConstructible() || mv->StoreType()->Is()) || + !mv->StoreType()->IsHostShareable()) { + AddError(var) << "vars in the 'uniform' address space must be host-shareable and " + "constructible or a buffer"; + return; + } + } else if (mv->AddressSpace() == AddressSpace::kImmediate) { + if (mv->StoreType() && !mv->StoreType()->IsHostShareable()) { + AddError(var) << "vars in the 'immediate' address space must be host-shareable"; + return; + } + + if (ContainsType(mv->StoreType())) { + AddError(var) << "vars in the 'immediate' address space cannot contain f16 types"; + return; + } + } else if (mv->AddressSpace() == core::AddressSpace::kPixelLocal) { + if (var->Block() == ir_.root_block) { + if (!mv->StoreType()->Is()) { + AddError(var) << "pixel_local var must be of type struct"; + return; + } + } + } +} + +void Functional::CheckLet(const Let* l) { + auto* value_ty = l->Value()->Type(); + auto* result_ty = l->Result()->Type(); + if (value_ty != result_ty) { + AddError(l) << "result type " << NameOf(l->Result()->Type()) + << " does not match value type " << NameOf(l->Value()->Type()); + } + + if (ir_.properties.Contains(Property::kAllowAnyLetType)) { + if (value_ty->Is()) { + AddError(l) << "value type cannot be void"; + } + return; + } + + if (!value_ty->IsConstructible() && !value_ty->Is()) { + AddError(l) << "value type, " << NameOf(value_ty) + << ", must be a concrete constructible type or a pointer type"; + } + + if (auto* ptr = result_ty->As()) { + if (ptr->AddressSpace() == AddressSpace::kHandle && + !ir_.properties.Contains(Property::kAllowPointerToHandle)) { + AddError(l) << "handle pointer cannot be captured in a let"; + } + } else if (!result_ty->IsConstructible()) { + AddError(l) << "result type, " << NameOf(result_ty) + << ", must be a concrete constructible type or a pointer type"; + } +} + +void Functional::CheckConstruct(const Construct* construct) { + auto* result_type = construct->Result()->Type(); + if (!result_type->IsConstructible()) { + // We only allow `construct` to create non-constructible types when they are structures that + // contain pointers and handle types, with the corresponding capability enabled. + if (!(result_type->Is() && + ir_.properties.Contains(Property::kAllowMslEntryPointInterface))) { + AddError(construct) << "type is not constructible"; + return; + } + } + + auto args = construct->Args(); + + // Zero-value constructors are valid for all constructible types. + if (args.empty()) { + return; + } + + // Check that type type of each argument matches the expected element type of the composite. + auto check_args_match_elements = [&] { + for (size_t i = 0; i < args.size(); i++) { + if (args[i]->Is()) { + continue; + } + auto* expected_type = result_type->Element(static_cast(i)); + if (args[i]->Type() != expected_type) { + AddError(construct, Construct::kArgsOperandOffset + i) + << "type " << NameOf(args[i]->Type()) << " of argument " << i + << " does not match expected type " << NameOf(expected_type); + } + } + }; + + if (result_type->Is()) { + // The only valid non-zero scalar constructor is the identity operation. + if (args.size() > 1) { + AddError(construct) << "scalar construct must not have more than one argument"; + } + if (args[0]->Type() != result_type) { + AddError(construct, 0u) << "scalar construct argument type " << NameOf(args[0]->Type()) + << " does not match result type " << NameOf(result_type); + } + return; + } + + if (auto* sg_mat = result_type->As()) { + if (args.size() > 1) { + AddError(construct) << "subgroup matrix construct must not have more than 1 argument"; + return; + } + + // 8-bit integer matrices use 32-bit shader scalar types in WGSL. + // Some backends may support 8-bit integers, in which case they would pass an 8-bit + // type for the constructor value instead. + const core::type::Type* scalar_ty = sg_mat->Type(); + if (scalar_ty->Is()) { + scalar_ty = type_mgr_.i32(); + } else if (scalar_ty->Is()) { + scalar_ty = type_mgr_.u32(); + } + if (args[0]->Type() != scalar_ty && args[0]->Type() != sg_mat->Type()) { + AddError(construct) << "subgroup matrix construct argument type " + << NameOf(args[0]->Type()) + << " does not match matrix shader scalar type " + << NameOf(scalar_ty); + } + return; + } + + if (auto* arr = result_type->As()) { + if (args.size() != arr->ConstantCount()) { + AddError(construct) << "array has " << arr->ConstantCount().value() + << " elements, but construct provides " << args.size() + << " arguments"; + return; + } + check_args_match_elements(); + return; + } + + if (auto* str = As(result_type)) { + auto members = str->Members(); + if (args.size() != str->Members().Length()) { + AddError(construct) << "structure has " << members.Length() + << " members, but construct provides " << args.size() + << " arguments"; + return; + } + check_args_match_elements(); + } + + auto table = intrinsic::Table(type_mgr_, symbols_); + auto arg_types = Transform<4>(args, [&](auto* v) { return v->Type(); }); + if (auto* vec = result_type->As()) { + auto ctor_conv = intrinsic::VectorCtorConv(vec->Width()); + auto match = table.Lookup(ctor_conv, Vector{vec->Type()}, + std::move(arg_types), core::EvaluationStage::kConstant); + if (match != Success || vec->Type() != arg_types[0]->DeepestElement()) { + AddError(construct) << "no matching overload for " << vec->FriendlyName() + << " constructor"; + } + return; + } + + if (auto* mat = result_type->As()) { + auto ctor_conv = intrinsic::MatrixCtorConv(mat->Columns(), mat->Rows()); + auto match = table.Lookup(ctor_conv, Vector{mat->Type()}, + std::move(arg_types), core::EvaluationStage::kConstant); + if (match != Success) { + AddError(construct) << "no matching overload for " << mat->FriendlyName() + << " constructor"; + } + return; + } +} + +void Functional::CheckCall(const Call* call) { + tint::Switch( + call, // + [&](const BuiltinCall* c) { CheckBuiltinCall(c); }, // + [&](const Construct* c) { CheckConstruct(c); }, // + [&](const Convert* c) { CheckConvert(c); }, // + [&](const Discard*) {}, // + [&](const MemberBuiltinCall* c) { CheckMemberBuiltinCall(c); }, // + [&](const UserCall* c) { CheckUserCall(c); }, // + [&](Default) { /* Validation of custom IR instructions */ }); +} + +void Functional::CheckAccess(const Access* a) { + auto* obj_view = a->Object()->Type()->As(); + auto* ty = obj_view ? obj_view->StoreType() : a->Object()->Type(); + + enum Kind : uint8_t { + kPtr, + kRef, + kValue, + }; + const Kind in_kind = tint::Switch( + a->Object()->Type(), // + [&](const core::type::Pointer*) { return kPtr; }, // + [&](const core::type::Reference*) { return kRef; }, // + [&](Default) { return kValue; }); + + auto desc_of = [&](Kind kind, const core::type::Type* type) { + switch (kind) { + case kPtr: + return StyledText{} + << style::Type("ptr<", obj_view->AddressSpace(), ", ", type->FriendlyName(), + ", ", obj_view->Access(), ">"); + case kRef: + return StyledText{} + << style::Type("ref<", obj_view->AddressSpace(), ", ", type->FriendlyName(), + ", ", obj_view->Access(), ">"); + default: + return NameOf(type); + } + }; + + for (size_t i = 0; i < a->Indices().size(); i++) { + auto err = [&]() -> diag::Diagnostic& { + return AddError(a, i + Access::kIndicesOperandOffset); + }; + + auto* index = a->Indices()[i]; + if (DAWN_UNLIKELY((!index->Type()->IsAnyOf()))) { + err() << "index type " << NameOf(index->Type()) << " must be i32 or u32"; + return; + } + + if (!ir_.properties.Contains(Property::kAllowVectorElementPointer)) { + if (in_kind != kValue && ty->Is()) { + err() << "cannot obtain address of vector element"; + return; + } + } + + if (auto* const_index = index->As()) { + auto* value = const_index->Value(); + if (value->Type()->IsSignedIntegerScalar()) { + // index is a signed integer scalar. Check that the index isn't negative. + // If the index is unsigned, we can skip this. + auto idx = value->ValueAs(); + if (DAWN_UNLIKELY(idx < 0)) { + err() << "constant index must be positive, got " << idx; + return; + } + } + + auto idx = value->ValueAs(); + auto* el = ty->Element(idx); + if (DAWN_UNLIKELY(!el)) { + // Is index in bounds? + if (auto el_count = ty->Elements().count; el_count != 0 && idx >= el_count) { + err() << "index out of bounds for type " << desc_of(in_kind, ty); + AddNote(a, i + Access::kIndicesOperandOffset) + << "acceptable range: [0.." << (el_count - 1) << "]"; + return; + } + err() << "type " << desc_of(in_kind, ty) << " cannot be indexed"; + return; + } + ty = el; + } else { + auto* el = ty->Elements().type; + if (DAWN_UNLIKELY(!el)) { + err() << "type " << desc_of(in_kind, ty) << " cannot be dynamically indexed"; + return; + } + ty = el; + } + } + + auto* want = a->Result()->Type(); + auto* want_view = want->As(); + bool ok = true; + if (obj_view) { + // Pointer source always means pointer result. + ok = (want_view != nullptr) && ty == want_view->StoreType(); + if (ok) { + // Also check that the address space and access modes match. + ok = obj_view->Is() == want_view->Is() && + obj_view->AddressSpace() == want_view->AddressSpace() && + obj_view->Access() == want_view->Access(); + } + } else { + // Otherwise, result types should exactly match. + ok = ty == want; + } + if (DAWN_UNLIKELY(!ok)) { + AddError(a) << "result of access chain is type " << desc_of(in_kind, ty) + << " but instruction type is " << NameOf(want); + } +} + +void Functional::CheckBinary(const Binary* b) { + intrinsic::Context context{b->TableData(), type_mgr_, symbols_}; + + auto overload = + core::intrinsic::LookupBinary(context, b->Op(), b->LHS()->Type(), b->RHS()->Type(), + core::EvaluationStage::kRuntime, /* is_compound */ false); + if (overload != Success) { + AddError(b) << overload.Failure(); + return; + } + + auto* result = b->Result(0); + TINT_ASSERT(result); + + if (overload->return_type != result->Type()) { + AddError(b) << "result value type " << NameOf(result->Type()) << " does not match " + << style::Instruction(b->Op()) << " result type " + << NameOf(overload->return_type); + } +} + +void Functional::CheckIf(const If* if_) { + if (!if_->Condition()->Type()->Is()) { + AddError(if_, If::kConditionOperandOffset) << "condition type must be 'bool'"; + } + + CheckBlock(if_->True()); + CheckBlock(if_->False()); +} + +bool Functional::CanLoad(const core::type::Type* ty) { + return tint::Switch( + ty, // + [&](const core::type::Array* arr) { + if (arr->Count()->Is()) { + return false; + } + return CanLoad(arr->Elements().type); + }, + [&](const core::type::Struct* str) { + for (auto* member : str->Members()) { + if (member->Type()->Is() && + ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + continue; + } + if (!CanLoad(member->Type())) { + return false; + } + } + return true; + }, + [&](Default) { return ty->IsConstructible() || ty->IsHandle(); }); +} + +void Functional::CheckLoad(const Load* l) { + const Value* from = l->From(); + TINT_ASSERT(from); + + auto* mv = from->Type()->As(); + if (!mv) { + AddError(l, Load::kFromOperandOffset) + << "load source operand " << NameOf(from->Type()) << " is not a memory view"; + return; + } + + if (mv->Access() != core::Access::kRead && mv->Access() != core::Access::kReadWrite) { + AddError(l, Load::kFromOperandOffset) + << "load source operand has a non-readable access type, " + << style::Literal(ToString(mv->Access())); + return; + } + + if (l->Result()->Type() != mv->StoreType()) { + AddError(l, Load::kFromOperandOffset) + << "result type " << NameOf(l->Result()->Type()) << " does not match source store type " + << NameOf(mv->StoreType()); + } + + if (!CanLoad(mv->StoreType())) { + AddError(l, Load::kFromOperandOffset) + << "type " << NameOf(mv->StoreType()) << " cannot be loaded"; + return; + } +} + +void Functional::CheckStore(const Store* s) { + const core::ir::Value* from = s->From(); + const core::ir::Value* to = s->To(); + TINT_ASSERT(from != nullptr); + TINT_ASSERT(to != nullptr); + + auto* mv = As(to->Type()); + if (!mv) { + AddError(s, Store::kToOperandOffset) + << "store target operand " << NameOf(to->Type()) << " is not a memory view"; + return; + } + + if (mv->Access() != core::Access::kWrite && mv->Access() != core::Access::kReadWrite) { + AddError(s, Store::kToOperandOffset) + << "store target operand has a non-writeable access type, " + << style::Literal(ToString(mv->Access())); + return; + } + + const core::type::Type* value_type = from->Type(); + const core::type::Type* store_type = mv->StoreType(); + if (value_type != store_type) { + AddError(s, Store::kFromOperandOffset) + << "value type " << NameOf(value_type) << " does not match store type " + << NameOf(store_type); + return; + } + + if (!store_type->IsConstructible()) { + AddError(s) << "store type " << NameOf(store_type) << " is not constructible"; + return; + } +} + +const core::type::Type* Functional::GetVectorPtrElementType(const Instruction* inst, size_t idx) { + auto* operand = inst->Operands()[idx]; + TINT_ASSERT(operand) << "missing element operand"; + + auto* type = operand->Type(); + TINT_ASSERT(type) << "missing operand type"; + + auto* memory_view_ty = type->As(); + if (DAWN_LIKELY(memory_view_ty)) { + auto* vec_ty = memory_view_ty->StoreType()->As(); + if (DAWN_LIKELY(vec_ty)) { + return vec_ty->Type(); + } + } + + AddError(inst, idx) << "operand " << NameOf(type) << " must be a pointer to a vector"; + return nullptr; +} + +void Functional::CheckLoadVectorElement(const LoadVectorElement* l) { + const core::type::Type* el_ty = + GetVectorPtrElementType(l, LoadVectorElement::kFromOperandOffset); + if (!el_ty) { + return; + } + + auto* res = l->Result(0); + if (res->Type() != el_ty) { + AddError(l) << "result type " << NameOf(res->Type()) + << " does not match vector pointer element type " << NameOf(el_ty); + return; + } + + if (!l->Index()->Type()->IsIntegerScalar()) { + AddError(l, LoadVectorElement::kIndexOperandOffset) + << "load vector element index must be an integer scalar"; + } + if (auto* c = l->Index()->As()) { + uint32_t val = c->Value()->ValueAs(); + + const core::type::Vector* vec_ty = + l->From()->Type()->UnwrapPtrOrRef()->As(); + TINT_ASSERT(vec_ty); + + if (val >= vec_ty->Width()) { + AddError(l, LoadVectorElement::kIndexOperandOffset) + << "load vector element index must be in range [0, " << (vec_ty->Width() - 1) + << "]"; + } + } +} + +void Functional::CheckStoreVectorElement(const StoreVectorElement* s) { + const core::type::Type* el_ty = + GetVectorPtrElementType(s, StoreVectorElement::kToOperandOffset); + if (!el_ty) { + return; + } + auto* value = s->Value(); + if (value->Type() != el_ty) { + AddError(s, StoreVectorElement::kValueOperandOffset) + << "value type " << NameOf(value->Type()) + << " does not match vector pointer element type " << NameOf(el_ty); + return; + } + + // The `GetVectorPtrElementType` has already validated that the pointer exists. + const core::type::MemoryView* mv = s->To()->Type()->As(); + if (mv->Access() != core::Access::kWrite && mv->Access() != core::Access::kReadWrite) { + AddError(s, StoreVectorElement::kToOperandOffset) + << "store_vector_element target operand has a non-writeable access type, " + << style::Literal(ToString(mv->Access())); + return; + } + + if (!s->Index()->Type()->IsIntegerScalar()) { + AddError(s, StoreVectorElement::kIndexOperandOffset) + << "store vector element index must be an integer scalar"; + } + + const core::ir::Constant* c = s->Index()->As(); + if (c == nullptr) { + return; + } + + uint32_t val = c->Value()->ValueAs(); + const core::type::Vector* vec_ty = s->To()->Type()->UnwrapPtrOrRef()->As(); + TINT_ASSERT(vec_ty); + + if (val >= vec_ty->Width()) { + AddError(s, StoreVectorElement::kIndexOperandOffset) + << "store vector element index must be in range [0, " << (vec_ty->Width() - 1) << "]"; + } +} + +void Functional::CheckLoop(const Loop* l) { + CheckBlock(l->Initializer()); + CheckLoopBody(l); + CheckLoopContinuing(l); + + first_continues_.Remove(l); +} + +void Functional::CheckLoopBody(const Loop* loop) { + CheckBlock(loop->Body()); +} + +void Functional::CheckLoopContinuing(const Loop* loop) { + // Ensure that values used in the loop continuing are not from the loop body, after a continue + // instruction. + auto* first_continue = first_continues_.GetOr(loop, nullptr); + if (first_continue == nullptr) { + return; + } + + // Find the instruction in the body block that is or holds the first continue instruction. + const Instruction* holds_continue = first_continue; + while (holds_continue && holds_continue->Block() && holds_continue->Block() != loop->Body()) { + holds_continue = holds_continue->Block()->Parent(); + } + + auto check_usage = [&](Usage use) { + if (TransitivelyHolds(loop->Continuing(), use.instruction)) { + AddError(use.instruction, use.operand_index) + << NameOf(use.instruction->Operands()[use.operand_index]) + << " cannot be used in continuing block as it is declared after the first " + << style::Instruction("continue") << " in the loop's body"; + AddNote(first_continue) << "loop body's first " << style::Instruction("continue"); + } + }; + + // Check that all subsequent instruction values are not used in the continuing block. + for (auto* inst = holds_continue; inst; inst = inst->next) { + for (auto* result : inst->Results()) { + result->ForEachUseUnsorted(check_usage); + } + } + + CheckBlock(loop->Continuing()); +} + +void Functional::CheckTerminator(const Terminator* b) { + tint::Switch( + b, // + [&](const ir::BreakIf* i) { CheckBreakIf(i); }, // + [&](const ir::Continue* c) { CheckContinue(c); }, // + [&](const ir::Exit* e) { CheckExit(e); }, // + [&](const ir::NextIteration*) {}, // + [&](const ir::Return* ret) { CheckReturn(ret); }, // + [&](const ir::TerminateInvocation*) {}, // + [&](const ir::Unreachable*) {}, // + TINT_ICE_ON_NO_MATCH); +} + +void Functional::CheckContinue(const Continue* c) { + auto* loop = c->Loop(); + TINT_ASSERT(loop); + + first_continues_.Add(loop, c); +} + +void Functional::CheckSwitch(const Switch* s) { + if (!s->Condition()->Type()->IsIntegerScalar()) { + auto* cond_ty = s->Condition() ? s->Condition()->Type() : nullptr; + AddError(s, Switch::kConditionOperandOffset) + << "condition type " << NameOf(cond_ty) << " must be an integer scalar"; + } + + bool found_default = false; + for (auto& case_ : s->Cases()) { + CheckBlock(case_.block); + + for (const auto& sel : case_.selectors) { + if (sel.IsDefault()) { + if (found_default) { + AddError(s) << "multiple default selectors in switch"; + } + found_default = true; + } else if (!sel.val->Type()->IsIntegerScalar()) { + AddError(s) << "case selector type " << NameOf(sel.val->Type()) + << " must be an integer scalar"; + } else if (sel.val->Type() != s->Condition()->Type()) { + AddError(s) << "case selector type " << NameOf(sel.val->Type()) + << " must match the switch condition type " + << NameOf(s->Condition()->Type()); + } + } + } + + if (!found_default) { + AddError(s) << "missing default case for switch"; + } +} + +void Functional::CheckSwizzle(const Swizzle* s) { + auto* src_vec = s->Object()->Type()->As(); + if (!src_vec) { + AddError(s) << "object of swizzle, " << NameOf(s->Object()) << ", is not a vector, " + << NameOf(s->Object()->Type()); + return; + } + + auto indices = s->Indices(); + if (indices.Length() < Swizzle::kMinNumIndices) { + AddError(s) << "expected at least " << Swizzle::kMinNumIndices << " indices"; + return; + } + + if (indices.Length() > Swizzle::kMaxNumIndices) { + AddError(s) << "expected at most " << Swizzle::kMaxNumIndices << " indices"; + return; + } + + auto elem_count = src_vec->Elements().count; + for (auto& idx : indices) { + if (idx > Swizzle::kMaxIndexValue || idx >= elem_count) { + AddError(s) << "invalid index value"; + return; + } + } + + auto* elem_ty = src_vec->Elements().type; + auto* expected_ty = type_mgr_.MatchWidth(elem_ty, indices.Length()); + auto* result_ty = s->Result()->Type(); + if (result_ty != expected_ty) { + AddError(s) << "result type " << NameOf(result_ty) << " does not match expected type, " + << NameOf(expected_ty); + return; + } +} + +void Functional::CheckUnary(const Unary* u) { + TINT_ASSERT(u->Val()); + + intrinsic::Context context{u->TableData(), type_mgr_, symbols_}; + auto overload = core::intrinsic::LookupUnary(context, u->Op(), u->Val()->Type(), + core::EvaluationStage::kRuntime); + if (overload != Success) { + AddError(u) << overload.Failure(); + return; + } + + const core::ir::Value* result = u->Result(0); + if (overload->return_type != result->Type()) { + AddError(u) << "result value type " << NameOf(result->Type()) << " does not match " + << style::Instruction(u->Op()) << " result type " + << NameOf(overload->return_type); + } +} + +void Functional::CheckBuiltinCall(const BuiltinCall* call) { + auto args = Transform<8>(call->Args(), [&](const ir::Value* v) { return v->Type(); }); + + intrinsic::Context context{call->TableData(), type_mgr_, symbols_}; + auto builtin = core::intrinsic::LookupFn(context, call->FriendlyName().c_str(), call->FuncId(), + call->ExplicitTemplateParams(), args, + core::EvaluationStage::kRuntime); + if (builtin != Success) { + AddError(call) << builtin.Failure(); + return; + } + + TINT_ASSERT(builtin->return_type); + + if (builtin->return_type != call->Result()->Type()) { + AddError(call) << "call result type " << NameOf(call->Result()->Type()) + << " does not match builtin return type " << NameOf(builtin->return_type); + return; + } + + // Check evaluation stage of parameters that are required to be const-expressions. + for (uint32_t i = 0; i < builtin->parameters.Length(); i++) { + const auto& p = builtin->parameters[i]; + const auto* arg = call->Args()[i]; + if (p.is_const && !arg->Is()) { + AddError(call, BuiltinCall::kArgsOperandOffset + i) + << "the " << style::Variable(p.usage) << " argument must be a constant"; + return; + } + } + + const core::ir::CoreBuiltinCall* bc = call->As(); + if (bc == nullptr) { + return; + } + + CheckCoreBuiltinCall(bc, builtin.Get()); +} + +void Functional::CheckCoreBuiltinCall(const CoreBuiltinCall* call, + const core::intrinsic::Overload& overload) { + auto idx_for_usage = [&](core::ParameterUsage usage) -> std::optional { + for (uint32_t i = 0; i < overload.parameters.Length(); ++i) { + auto& p = overload.parameters[i]; + if (p.usage == usage) { + return int32_t(i); + } + } + return std::nullopt; + }; + + auto check_arg_in_range = [&](core::ParameterUsage usage, int32_t min, int32_t max) { + auto idx_opt = idx_for_usage(usage); + if (!idx_opt.has_value()) { + return; + } + uint32_t idx = idx_opt.value(); + TINT_ASSERT(idx < call->Args().size()); + + auto* val = call->Args()[idx]; + auto* const_val = val->As(); + TINT_ASSERT(const_val); + auto* cnst = const_val->Value(); + + if (val->Type()->Is()) { + for (size_t i = 0; i < cnst->NumElements(); i++) { + auto value = cnst->Index(i)->ValueAs(); + if (value < min || value > max) { + AddError(call, idx) + << value << " outside range of [" << min << ", " << max << "]"; + return; + } + } + } else { + auto value = cnst->ValueAs(); + if (value < min || value > max) { + AddError(call, idx) << value << " outside range of [" << min << ", " << max << "]"; + return; + } + } + }; + + if (core::IsTexture(call->Func())) { + check_arg_in_range(core::ParameterUsage::kComponent, 0, 3); + check_arg_in_range(core::ParameterUsage::kOffset, -8, 7); + } + + if (call->Func() == core::BuiltinFn::kSubgroupMatrixLoad || + call->Func() == core::BuiltinFn::kSubgroupMatrixStore) { + CheckSubgroupMatrixOpOffset(call); + } +} + +void Functional::CheckSubgroupMatrixOpOffset(const CoreBuiltinCall* call) { + const core::ir::Value* p_arg = call->Args()[0]; + const core::ir::Value* offset_arg = call->Args()[1]; + + const core::type::Pointer* ptr_ty = p_arg->Type()->As(); + TINT_ASSERT(ptr_ty); + + const core::type::Array* arr_ty = ptr_ty->StoreType()->As(); + TINT_ASSERT(arr_ty); + + auto const_count = arr_ty->ConstantCount(); + if (!const_count.has_value()) { + return; + } + + const core::type::SubgroupMatrix* mat_ty = nullptr; + if (call->Func() == core::BuiltinFn::kSubgroupMatrixLoad) { + mat_ty = call->Result()->Type()->As(); + } else if (call->Func() == core::BuiltinFn::kSubgroupMatrixStore) { + mat_ty = call->Args()[2]->Type()->As(); + } + TINT_ASSERT(mat_ty); + + auto arr_elem_size = arr_ty->ElemType()->Size(); + auto mat_comp_size = mat_ty->Type()->Size(); + TINT_ASSERT(mat_comp_size > 0); + + auto limit = (const_count.value() * arr_elem_size) / mat_comp_size; + + if (auto* offset_const = offset_arg->As()) { + auto* offset_val = offset_const->Value(); + uint32_t offset = 0; + if (offset_arg->Type()->IsUnsignedIntegerScalar()) { + offset = offset_val->ValueAs(); + } else if (offset_arg->Type()->IsSignedIntegerScalar()) { + auto ival = offset_val->ValueAs(); + if (ival < 0) { + AddError(call, 1) << "the offset argument of " << call->Func() + << " must be non-negative"; + return; + } + offset = static_cast(ival); + } + + if (offset >= limit) { + AddError(call, 1) << "the offset argument of " << call->Func() << " (" << offset + << ") is out of bounds of the array type of size " << limit; + } + } +} + +void Functional::CheckMemberBuiltinCall(const MemberBuiltinCall* call) { + auto args = Transform<8>(call->Args(), [&](const ir::Value* v) { return v->Type(); }); + args.Insert(0, call->Object()->Type()); + + intrinsic::Context context{call->TableData(), type_mgr_, symbols_}; + auto result = core::intrinsic::LookupMemberFn(context, call->FriendlyName().c_str(), + call->FuncId(), call->ExplicitTemplateParams(), + std::move(args), core::EvaluationStage::kRuntime); + if (result != Success) { + AddError(call) << result.Failure(); + return; + } + + if (result->return_type != call->Result()->Type()) { + // Note: This is not currently tested in core unittests as there are no concrete + // MemberBuiltinCall implementations in core IR. This is tested by backend-specific + // (e.g. HLSL) validation tests. + AddError(call) << "member call result type " << NameOf(call->Result()->Type()) + << " does not match builtin return type " << NameOf(result->return_type); + } +} + +void Functional::CheckConvert(const Convert* convert) { + auto* result_type = convert->Result()->Type(); + auto* value_type = convert->Operand(Convert::kValueOperandOffset)->Type(); + + intrinsic::CtorConv conv_ty; + Vector template_type; + tint::Switch( + result_type, // + [&](const core::type::I32*) { conv_ty = intrinsic::CtorConv::kI32; }, // + [&](const core::type::U32*) { conv_ty = intrinsic::CtorConv::kU32; }, // + [&](const core::type::U64*) { conv_ty = intrinsic::CtorConv::kU64; }, // + [&](const core::type::F32*) { conv_ty = intrinsic::CtorConv::kF32; }, // + [&](const core::type::F16*) { conv_ty = intrinsic::CtorConv::kF16; }, // + [&](const core::type::Bool*) { conv_ty = intrinsic::CtorConv::kBool; }, // + [&](const core::type::Vector* v) { + conv_ty = intrinsic::VectorCtorConv(v->Width()); + template_type.Push(v->Type()); + }, + [&](const core::type::Matrix* m) { + conv_ty = intrinsic::MatrixCtorConv(m->Columns(), m->Rows()); + template_type.Push(m->Type()); + }, + [&](Default) { conv_ty = intrinsic::CtorConv::kNone; }); + + if (conv_ty == intrinsic::CtorConv::kNone) { + AddError(convert) << "not defined for result type, " << NameOf(result_type); + return; + } + + auto table = intrinsic::Table(type_mgr_, symbols_); + auto match = + table.Lookup(conv_ty, template_type, Vector{value_type}, core::EvaluationStage::kOverride); + if (match != Success || !match->info->flags.Contains(intrinsic::OverloadFlag::kIsConverter)) { + AddError(convert) << "No defined converter for " << NameOf(value_type) << " -> " + << NameOf(result_type); + return; + } +} + +void Functional::CheckUserCall(const UserCall* call) { + if (call->Target()->IsEntryPoint()) { + AddError(call, UserCall::kFunctionOperandOffset) + << "call target must not have a pipeline stage"; + } + + if (call->Target()->ReturnType() != call->Result()->Type()) { + AddError(call) << "result type does not match function return type"; + return; + } + + auto args = call->Args(); + auto params = call->Target()->Params(); + if (args.size() != params.Length()) { + AddError(call, UserCall::kFunctionOperandOffset) + << "function has " << params.Length() << " parameters, but call provides " + << args.size() << " arguments"; + return; + } + + for (size_t i = 0; i < args.size(); i++) { + bool allow_mismatch = false; + if (auto* arg_buffer_ty = args[i]->Type()->UnwrapPtrOrRef()->As()) { + auto* arg_ptr_ty = args[i]->Type()->As(); + if (auto* param_ptr_ty = params[i]->Type()->As()) { + if (auto* param_buffer_ty = + param_ptr_ty->UnwrapPtrOrRef()->As()) { + allow_mismatch = arg_ptr_ty->AddressSpace() == param_ptr_ty->AddressSpace() && + arg_ptr_ty->Access() == param_ptr_ty->Access(); + const bool both_constant = + arg_buffer_ty->Count()->Is() && + param_buffer_ty->Count()->Is(); + uint32_t arg_size = arg_buffer_ty->ConstantCount().value_or(0); + uint32_t param_size = param_buffer_ty->ConstantCount().value_or(0); + allow_mismatch &= + param_buffer_ty->Count()->Is() || + (both_constant && param_size < arg_size); + } + } + } + if (!allow_mismatch && args[i]->Type() != params[i]->Type()) { + AddError(call, UserCall::kArgsOperandOffset + i) + << "type " << NameOf(params[i]->Type()) << " of function parameter " << i + << " does not match argument type " << NameOf(args[i]->Type()); + } + } +} + +void Functional::CheckBreakIf(const BreakIf* b) { + if (!b->Condition()->Type() || !b->Condition()->Type()->Is()) { + AddError(b) << "condition must be a 'bool'"; + return; + } + + auto* loop = b->Loop(); + TINT_ASSERT(loop); + + if (loop->Continuing() != b->Block()) { + AddError(b) << "must only be called directly from loop continuing"; + } +} + +void Functional::CheckExit(const Exit* e) { + tint::Switch( + e, // + [&](const ir::ExitIf*) {}, // + [&](const ir::ExitLoop* l) { CheckExitLoop(l); }, // + [&](const ir::ExitSwitch*) {}, // + TINT_ICE_ON_NO_MATCH); +} + +void Functional::CheckExitLoop(const ExitLoop* l) { + const Instruction* inst = l; + const Loop* control = l->Loop(); + while (inst) { + // Found parent loop + if (inst->Block()->Parent() == control) { + if (inst->Block() == control->Continuing()) { + AddError(l) << "loop exit jumps out of continuing block"; + if (control->Continuing() != l->Block()) { + AddNote(control->Continuing()) << "in continuing block"; + } + } else if (inst->Block() == control->Initializer()) { + AddError(l) << "loop exit not permitted in loop initializer"; + if (control->Initializer() != l->Block()) { + AddNote(control->Initializer()) << "in initializer block"; + } + } + break; + } + inst = inst->Block()->Parent(); + } +} + +void Functional::CheckReturn(const Return* ret) { + auto* func = ret->Func(); + TINT_ASSERT(func); + + if (func->ReturnType()->Is()) { + if (ret->HasValue()) { + AddError(ret) << "unexpected return value"; + } + return; + } + + if (!ret->Value()) { + AddError(ret) << "expected return value"; + } else if (ret->Value()->Type() != func->ReturnType()) { + AddError(ret) << "return value type " << NameOf(ret->Value()->Type()) + << " does not match function return type " << NameOf(func->ReturnType()); + } +} + +} // namespace tint::core::ir::validator diff --git a/3rdparty/dawn/src/tint/lang/core/ir/functional_validator.h b/3rdparty/dawn/src/tint/lang/core/ir/functional_validator.h new file mode 100644 index 000000000..5363df825 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/functional_validator.h @@ -0,0 +1,180 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_CORE_IR_FUNCTIONAL_VALIDATOR_H_ +#define SRC_TINT_LANG_CORE_IR_FUNCTIONAL_VALIDATOR_H_ + +#include + +#include "src/tint/lang/core/intrinsic/table.h" +#include "src/tint/lang/core/ir/access.h" +#include "src/tint/lang/core/ir/binary.h" +#include "src/tint/lang/core/ir/block.h" +#include "src/tint/lang/core/ir/break_if.h" +#include "src/tint/lang/core/ir/builtin_call.h" +#include "src/tint/lang/core/ir/call.h" +#include "src/tint/lang/core/ir/construct.h" +#include "src/tint/lang/core/ir/continue.h" +#include "src/tint/lang/core/ir/convert.h" +#include "src/tint/lang/core/ir/core_builtin_call.h" +#include "src/tint/lang/core/ir/disassembler.h" +#include "src/tint/lang/core/ir/exit.h" +#include "src/tint/lang/core/ir/exit_loop.h" +#include "src/tint/lang/core/ir/if.h" +#include "src/tint/lang/core/ir/let.h" +#include "src/tint/lang/core/ir/load.h" +#include "src/tint/lang/core/ir/load_vector_element.h" +#include "src/tint/lang/core/ir/loop.h" +#include "src/tint/lang/core/ir/member_builtin_call.h" +#include "src/tint/lang/core/ir/module.h" +#include "src/tint/lang/core/ir/override.h" +#include "src/tint/lang/core/ir/return.h" +#include "src/tint/lang/core/ir/store.h" +#include "src/tint/lang/core/ir/store_vector_element.h" +#include "src/tint/lang/core/ir/switch.h" +#include "src/tint/lang/core/ir/swizzle.h" +#include "src/tint/lang/core/ir/unary.h" +#include "src/tint/lang/core/ir/user_call.h" +#include "src/tint/lang/core/ir/var.h" +#include "src/tint/utils/containers/hashmap.h" +#include "src/tint/utils/diagnostic/diagnostic.h" + +namespace tint::core::ir::validator { + +class Functional { + public: + enum class ErrorSource { + kWgsl, + kIr, + }; + + Functional(const Module& ir, diag::List& diagnostics, ErrorSource error_source); + ~Functional(); + + void Validate(); + + Functional(const Functional&) = delete; + Functional(Functional&&) = delete; + Functional& operator=(const Functional&) = delete; + Functional& operator=(Functional&&) = delete; + + private: + using SourceHelper = std::function; + + /// ScopeStack holds a stack of values that are currently in scope + struct ScopeStack { + void Push() { stack_.Push({}); } + void Pop() { stack_.Pop(); } + void Add(const Value* value) { stack_.Back().Add(value); } + bool Contains(const Value* value) { + return stack_.Any([&](auto& v) { return v.Contains(value); }); + } + bool IsEmpty() const { return stack_.IsEmpty(); } + + private: + Vector, 4> stack_; + }; + + StyledText NameOf(const core::type::Type* ty); + StyledText NameOf(const Value* value); + + Source SourceOf(const Function* func); + Source SourceOf(const FunctionParam* param); + Source SourceOf(const Instruction* inst); + Source SourceOf(const Instruction* inst, size_t idx); + + diag::Diagnostic& AddError(Source src); + diag::Diagnostic& AddError(const Function* func); + diag::Diagnostic& AddError(const FunctionParam* param); + diag::Diagnostic& AddError(const Instruction* inst); + diag::Diagnostic& AddError(const Instruction* inst, size_t idx); + + diag::Diagnostic& AddNote(Source src); + diag::Diagnostic& AddNote(const Block* blk); + diag::Diagnostic& AddNote(const Instruction* inst); + diag::Diagnostic& AddNote(const Instruction* inst, size_t idx); + + ir::Disassembler& Disassemble(); + + bool CanLoad(const core::type::Type* ty); + const core::type::Type* GetVectorPtrElementType(const Instruction* inst, size_t idx); + + void CheckRootBlock(const Block* blk); + void CheckFunction(const Function* func); + void CheckFunctionParam(const FunctionParam* param); + void CheckBlock(const Block* blk); + void CheckInstruction(const Instruction* inst); + + void CheckAccess(const Access* a); + void CheckBinary(const Binary* b); + void CheckBreakIf(const BreakIf* b); + void CheckBuiltinCall(const BuiltinCall* call); + void CheckCall(const Call* call); + void CheckConstruct(const Construct* construct); + void CheckContinue(const Continue* c); + void CheckConvert(const Convert* convert); + void CheckCoreBuiltinCall(const CoreBuiltinCall* call, + const core::intrinsic::Overload& overload); + void CheckExit(const Exit* e); + void CheckExitLoop(const ExitLoop* l); + void CheckIf(const If* if_); + void CheckLet(const Let* l); + void CheckLoad(const Load* l); + void CheckLoadVectorElement(const LoadVectorElement* l); + void CheckLoop(const Loop* l); + void CheckLoopBody(const Loop* loop); + void CheckLoopContinuing(const Loop* loop); + void CheckMemberBuiltinCall(const MemberBuiltinCall* call); + void CheckOverride(const Override* o); + void CheckReturn(const Return* ret); + void CheckStore(const Store* s); + void CheckStoreVectorElement(const StoreVectorElement* s); + void CheckSubgroupMatrixOpOffset(const CoreBuiltinCall* call); + void CheckSwitch(const Switch* s); + void CheckSwizzle(const Swizzle* s); + void CheckTerminator(const Terminator* b); + void CheckUnary(const Unary* u); + void CheckUserCall(const UserCall* call); + void CheckVar(const Var* var); + + const Module& ir_; + diag::List& diag_; + ErrorSource error_source_; + std::optional disassembler_; // Use Disassemble() + + SymbolTable symbols_ = SymbolTable::Wrap(ir_.symbols); + core::type::Manager type_mgr_ = core::type::Manager::Wrap(ir_.Types()); + + Vector block_stack_; + Hashset seen_override_ids_; + Hashmap first_continues_; + Hashset entry_point_names_; +}; + +} // namespace tint::core::ir::validator + +#endif // SRC_TINT_LANG_CORE_IR_FUNCTIONAL_VALIDATOR_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/io_attribute_validator.cc b/3rdparty/dawn/src/tint/lang/core/ir/io_attribute_validator.cc new file mode 100644 index 000000000..b7b2ee895 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/io_attribute_validator.cc @@ -0,0 +1,621 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/tint/lang/core/ir/io_attribute_validator.h" + +#include "src/tint/lang/core/type/array.h" +#include "src/tint/lang/core/type/bool.h" +#include "src/tint/lang/core/type/f32.h" +#include "src/tint/lang/core/type/u32.h" +#include "src/tint/lang/core/type/vector.h" + +namespace tint::core::ir::validator { +namespace { + +/// A BuiltInChecker is the interface used to check that a usage of a builtin attribute meets the +/// basic spec rules, i.e. correct shader stage, data type, and IO direction. +/// It does not test more sophisticated rules like location and builtins being mutually exclusive or +/// that the correct capabilities are enabled. +struct BuiltInChecker { + /// What combination of stage and IO direction is this builtin legal for + EnumSet valid_usages; + + /// What values for depth_mode are valid for this builtin. + /// Currently, kUndefined is the only valid option for non-frag_depth + EnumSet valid_depth_modes = + EnumSet{BuiltinDepthMode::kUndefined}; + + /// Implements logic for checking if the given type is valid or not. Is not a data entry (i.e. a + /// type or set of types), because types are part of the IR module and created at runtime. + using TypeCheckFn = bool(const core::type::Type* type, const Properties& props); + + /// @see #TypeCheckFn + TypeCheckFn* const type_check; + + /// Message for logging if the type check fails. Cannot be easily generated at runtime, because + /// the type check is a function, not just a data entry. + const char* type_error; +}; + +constexpr BuiltInChecker kPointSizeChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be a f32", +}; + +/// returns true if the number of elements in @p ty is valid for use in clip_distances without +/// Capability::kAllowClipDistancesOnF32. +constexpr auto ClipDistancesElementsCheck = [](const core::type::Type* ty) -> bool { + const auto elems = ty->Elements(); + return elems.type && elems.type->Is() && elems.count <= 8; +}; + +constexpr BuiltInChecker kClipDistancesChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is() && ClipDistancesElementsCheck(ty); + }, + .type_error = "must be an array, where N <= 8", +}; + +constexpr BuiltInChecker kClipDistancesAllowF32ScalarAndVectorChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ((ty->Is() || ty->Is()) && + ClipDistancesElementsCheck(ty)) || + ty->Is(); + }, + .type_error = "must be a f32 or either a vecN or an array, where N <= 8", +}; + +constexpr BuiltInChecker kCullDistanceChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is() && ty->DeepestElement()->Is(); + }, + .type_error = "must be an array of f32", +}; + +constexpr BuiltInChecker kFragDepthChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentOutputUsage}, + .valid_depth_modes = + EnumSet{BuiltinDepthMode::kUndefined, BuiltinDepthMode::kGreater, + BuiltinDepthMode::kLess}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be a f32", +}; + +constexpr BuiltInChecker kFrontFacingChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be a bool", +}; + +constexpr BuiltInChecker kGlobalInvocationIdChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + auto* vec = ty->As(); + return vec && vec->Width() == 3 && vec->Type()->Is(); + }, + .type_error = "must be an vec3", +}; + +constexpr BuiltInChecker kInstanceIndexChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kLocalInvocationIdChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + auto* vec = ty->As(); + return vec && vec->Width() == 3 && vec->Type()->Is(); + }, + .type_error = "must be an vec3", +}; + +constexpr BuiltInChecker kLocalInvocationIndexChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kNumSubgroupsChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kNumWorkgroupsChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + auto* vec = ty->As(); + return vec && vec->Width() == 3 && vec->Type()->Is(); + }, + .type_error = "must be an vec3", +}; + +constexpr BuiltInChecker kPositionChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage, + IOAttributeUsage::kFragmentInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + auto* vec = ty->As(); + return vec && vec->Width() == 4 && vec->Type()->Is(); + }, + .type_error = "must be an vec4", +}; + +constexpr BuiltInChecker kSampleIndexChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kSampleMaskChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage, + IOAttributeUsage::kFragmentOutputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kSubgroupIdChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kSubgroupInvocationIdChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage, + IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kSubgroupSizeChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage, + IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kVertexIndexChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kVertexInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kWorkgroupIdChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + auto* vec = ty->As(); + return vec && vec->Width() == 3 && vec->Type()->Is(); + }, + .type_error = "must be an vec3", +}; + +constexpr BuiltInChecker kPrimitiveIndexChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->Is(); + }, + .type_error = "must be an u32", +}; + +constexpr BuiltInChecker kBarycentricCoordChecker{ + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + auto* vec = ty->As(); + return vec && vec->Width() == 3 && vec->Type()->Is(); + }, + .type_error = "must be an vec3", +}; + +/// @returns an appropriate BuiltInCheck for @p builtin, ICEs when one isn't defined +const BuiltInChecker& BuiltinCheckerFor(BuiltinValue builtin, const Properties& properties) { + switch (builtin) { + case BuiltinValue::kPointSize: + return kPointSizeChecker; + case BuiltinValue::kClipDistances: + if (properties.Contains(Property::kAllowClipDistancesOnF32ScalarAndVector)) { + return kClipDistancesAllowF32ScalarAndVectorChecker; + } + return kClipDistancesChecker; + case BuiltinValue::kCullDistance: + return kCullDistanceChecker; + case BuiltinValue::kFragDepth: + return kFragDepthChecker; + case BuiltinValue::kFrontFacing: + return kFrontFacingChecker; + case BuiltinValue::kGlobalInvocationId: + return kGlobalInvocationIdChecker; + case BuiltinValue::kInstanceIndex: + return kInstanceIndexChecker; + case BuiltinValue::kLocalInvocationId: + return kLocalInvocationIdChecker; + case BuiltinValue::kLocalInvocationIndex: + case BuiltinValue::kGlobalInvocationIndex: + case BuiltinValue::kWorkgroupIndex: + return kLocalInvocationIndexChecker; + case BuiltinValue::kNumSubgroups: + return kNumSubgroupsChecker; + case BuiltinValue::kNumWorkgroups: + return kNumWorkgroupsChecker; + case BuiltinValue::kPosition: + return kPositionChecker; + case BuiltinValue::kSampleIndex: + return kSampleIndexChecker; + case BuiltinValue::kSampleMask: + return kSampleMaskChecker; + case BuiltinValue::kSubgroupId: + return kSubgroupIdChecker; + case BuiltinValue::kSubgroupInvocationId: + return kSubgroupInvocationIdChecker; + case BuiltinValue::kSubgroupSize: + return kSubgroupSizeChecker; + case BuiltinValue::kVertexIndex: + return kVertexIndexChecker; + case BuiltinValue::kWorkgroupId: + return kWorkgroupIdChecker; + case BuiltinValue::kPrimitiveIndex: + return kPrimitiveIndexChecker; + case BuiltinValue::kBarycentricCoord: + return kBarycentricCoordChecker; + default: + TINT_ICE() << builtin << " is does not have a checker defined for it"; + } +} + +constexpr IOAttributeChecker kInvariantChecker{ + .kind = IOAttributeKind::kInvariant, + .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage, + IOAttributeUsage::kFragmentInputUsage}, + .valid_io_kinds = EnumSet{ShaderIOKind::kInputParam, ShaderIOKind::kResultValue, + ShaderIOKind::kModuleScopeVar}, + .check = [](const core::type::Type*, + const IOAttributes& attr, + const Properties&, + IOAttributeUsage) -> Result { + if (attr.builtin != BuiltinValue::kPosition) { + return {"invariant can only decorate a value if it is also decorated with position"}; + } + return Success; + }, + .type_check = kPositionChecker.type_check, + .type_error = kPositionChecker.type_error, +}; + +constexpr IOAttributeChecker kBuiltinChecker{ + .kind = IOAttributeKind::kBuiltin, + .valid_usages = + EnumSet{ + IOAttributeUsage::kComputeInputUsage, + IOAttributeUsage::kComputeOutputUsage, + IOAttributeUsage::kFragmentInputUsage, + IOAttributeUsage::kFragmentOutputUsage, + IOAttributeUsage::kVertexInputUsage, + IOAttributeUsage::kVertexOutputUsage, + }, + .valid_io_kinds = EnumSet{ShaderIOKind::kInputParam, ShaderIOKind::kResultValue, + ShaderIOKind::kModuleScopeVar}, + .check = [](const core::type::Type* ty, + const IOAttributes& attr, + const Properties& prop, + IOAttributeUsage usage) -> Result { + if (!attr.builtin.has_value()) { + return Success; + } + + const auto builtin = attr.builtin.value(); + const auto& checker = BuiltinCheckerFor(builtin, prop); + if (usage != IOAttributeUsage::kUndefinedUsage && !checker.valid_usages.Contains(usage)) { + std::stringstream msg; + msg << ToString(builtin) << " cannot be used on a " << ToString(usage) << ". "; + if (checker.valid_usages.Size() == 1) { + const auto v = *checker.valid_usages.begin(); + msg << "It can only be used on a " << ToString(v) << "."; + } else { + msg << "It can only be used on one of " << ToString(checker.valid_usages); + } + return msg.str(); + } + + if (!checker.type_check(ty, prop)) { + std::stringstream msg; + msg << ToString(builtin) << " " << checker.type_error; + return msg.str(); + } + + const auto depth_mode = attr.depth_mode.value_or(BuiltinDepthMode::kUndefined); + if (!checker.valid_depth_modes.Contains(depth_mode)) { + std::stringstream msg; + msg << ToString(builtin) << " cannot have a depth mode of " << ToString(depth_mode) + << ". "; + if (checker.valid_depth_modes.Size() == 1) { + const auto v = *checker.valid_depth_modes.begin(); + msg << "It can only be " << ToString(v) << "."; + } else { + msg << "It must be one of " << ToString(checker.valid_depth_modes); + } + return msg.str(); + } + + if (builtin == BuiltinValue::kPointSize && + !prop.Contains(Property::kAllowPointSizeBuiltin)) { + return std::string{"use of point_size builtin requires kAllowPointSizeBuiltin"}; + } + + return Success; + }, + .type_check = [](const core::type::Type*, const Properties&) -> bool { return true; }, + .type_error = nullptr, +}; + +constexpr IOAttributeChecker kColorChecker{ + .kind = IOAttributeKind::kColor, + .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, + .valid_io_kinds = + EnumSet{ShaderIOKind::kInputParam, ShaderIOKind::kModuleScopeVar}, + .check = [](const core::type::Type*, const IOAttributes&, const Properties&, IOAttributeUsage) + -> Result { return Success; }, + .type_check = [](const core::type::Type* ty, const Properties&) -> bool { + return ty->IsNumericScalarOrVector(); + }, + .type_error = "must be a numeric scalar or vector", +}; + +constexpr IOAttributeChecker kInputAttachmentIndexChecker{ + .kind = IOAttributeKind::kInputAttachmentIndex, + .valid_usages = EnumSet{IOAttributeUsage::kFragmentResourceUsage}, + .valid_io_kinds = EnumSet{ShaderIOKind::kModuleScopeVar}, + .check = [](const core::type::Type*, const IOAttributes&, const Properties&, IOAttributeUsage) + -> Result { return Success; }, + .type_check = [](const core::type::Type* ty, const Properties& props) -> bool { + return props.Contains(Property::kAllowAnyInputAttachmentIndexType) || + ty->Is(); + }, + .type_error = "must be an input_attachment", +}; + +constexpr IOAttributeChecker kDepthModeChecker{ + .kind = IOAttributeKind::kDepthMode, + .valid_usages = kBuiltinChecker.valid_usages, + .valid_io_kinds = kBuiltinChecker.valid_io_kinds, + // kBuiltInChecker does the checking of the depth_mode value for the specific builtin. + .check = [](const core::type::Type*, + const IOAttributes& attr, + const Properties&, + IOAttributeUsage) -> Result { + if (!attr.builtin.has_value()) { + return {"cannot have a depth_mode without a builtin"}; + } + return Success; + }, + .type_check = [](const core::type::Type*, const Properties&) -> bool { return true; }, + .type_error = nullptr, +}; + +// kBlendSrcChecker, kLocationChecker, kInterpolationChecker, and kBindingPointChecker are +// intentionally not implemented + +} // namespace + +Vector IOAttributeCheckersFor(const IOAttributes& attr, + bool skip_builtin) { + Vector checkers{}; + if (attr.invariant) { + checkers.Push(&kInvariantChecker); + } + if (!skip_builtin && attr.builtin.has_value()) { + checkers.Push(&kBuiltinChecker); + } + if (attr.color.has_value()) { + checkers.Push(&kColorChecker); + } + if (attr.input_attachment_index.has_value()) { + checkers.Push(&kInputAttachmentIndexChecker); + } + if (attr.depth_mode.has_value()) { + checkers.Push(&kDepthModeChecker); + } + + // attr.blend_src, attr.location, attr.interpolation, and attr.binding_point are intentionally + // skipped, because their rules are not amenable to implementation via IOAttributeChecker. + return checkers; +} + +std::string ToString(IOAttributeUsage value) { + switch (value) { + case IOAttributeUsage::kComputeInputUsage: + return "compute shader input"; + case IOAttributeUsage::kComputeOutputUsage: + return "compute shader output"; + case IOAttributeUsage::kComputeResourceUsage: + return "compute shader resource"; + case IOAttributeUsage::kFragmentInputUsage: + return "fragment shader input"; + case IOAttributeUsage::kFragmentOutputUsage: + return "fragment shader output"; + case IOAttributeUsage::kFragmentResourceUsage: + return "fragment shader resource"; + case IOAttributeUsage::kVertexInputUsage: + return "vertex shader input"; + case IOAttributeUsage::kVertexOutputUsage: + return "vertex shader output"; + case IOAttributeUsage::kVertexResourceUsage: + return "vertex shader resourcee"; + case IOAttributeUsage::kUndefinedUsage: + return "non-entry point usage"; + } + TINT_ICE() << "Unknown enum passed to ToString(IOAttribute)"; +} + +IOAttributeUsage IOAttributeUsageFor(Function::PipelineStage stage, IODirection direction) { + switch (stage) { + case Function::PipelineStage::kCompute: + switch (direction) { + case IODirection::kInput: + return IOAttributeUsage::kComputeInputUsage; + case IODirection::kOutput: + return IOAttributeUsage::kComputeOutputUsage; + case IODirection::kResource: + return IOAttributeUsage::kComputeResourceUsage; + } + break; + case Function::PipelineStage::kFragment: + switch (direction) { + case IODirection::kInput: + return IOAttributeUsage::kFragmentInputUsage; + case IODirection::kOutput: + return IOAttributeUsage::kFragmentOutputUsage; + case IODirection::kResource: + return IOAttributeUsage::kFragmentResourceUsage; + } + break; + case Function::PipelineStage::kVertex: + switch (direction) { + case IODirection::kInput: + return IOAttributeUsage::kVertexInputUsage; + case IODirection::kOutput: + return IOAttributeUsage::kVertexOutputUsage; + case IODirection::kResource: + return IOAttributeUsage::kVertexResourceUsage; + } + break; + case Function::PipelineStage::kUndefined: + return IOAttributeUsage::kUndefinedUsage; + } + TINT_ICE() << "Unknown IOAttribute usage " << ToString(direction) << " for a " + << ToString(stage) << " entry point"; +} + +std::string ToString(ShaderIOKind value) { + switch (value) { + case ShaderIOKind::kInputParam: + return "input param"; + case ShaderIOKind::kResultValue: + return "return value"; + case ShaderIOKind::kModuleScopeVar: + return "module scope variable"; + } + TINT_ICE() << "Unknown enum passed to ToString(ShaderIOKind)"; +} + +std::string_view ToString(IODirection value) { + switch (value) { + case IODirection::kInput: + return "input"; + case IODirection::kOutput: + return "output"; + case IODirection::kResource: + return "resource"; + } + TINT_ICE() << "Unknown enum passed to ToString(IODirection)"; +} + +IODirection IODirectionFor(AddressSpace address_space) { + switch (address_space) { + case AddressSpace::kIn: + return IODirection::kInput; + case AddressSpace::kOut: + return IODirection::kOutput; + case AddressSpace::kHandle: + return IODirection::kResource; + default: + TINT_ICE() << "Unexpected address_space '" << ToString(address_space) + << "' passed to IODirectionFrom()"; + } +} + +std::string ToString(IOAnnotation value) { + switch (value) { + case IOAnnotation::kBindingPoint: + return "@group + @binding"; + case IOAnnotation::kLocation: + return "@location"; + case IOAnnotation::kBuiltin: + return "built-in"; + case IOAnnotation::kWorkgroup: + return ""; + case IOAnnotation::kColor: + return "@color"; + } + TINT_ICE() << "Unknown enum passed to ToString(IOAnnotation)"; +} + +Result AddIOAnnotationsFromIOAttributes( + EnumSet& annotations, + const IOAttributes& attr) { + if (attr.location.has_value()) { + if (annotations.Contains(IOAnnotation::kLocation)) { + return IOAnnotation::kLocation; + } + annotations.Add(IOAnnotation::kLocation); + } + + if (attr.builtin.has_value()) { + if (annotations.Contains(IOAnnotation::kBuiltin)) { + return IOAnnotation::kBuiltin; + } + annotations.Add(IOAnnotation::kBuiltin); + } + + if (attr.color.has_value()) { + if (annotations.Contains(IOAnnotation::kColor)) { + return IOAnnotation::kColor; + } + annotations.Add(IOAnnotation::kColor); + } + + return Success; +} + +} // namespace tint::core::ir::validator diff --git a/3rdparty/dawn/src/tint/lang/core/ir/io_attribute_validator.h b/3rdparty/dawn/src/tint/lang/core/ir/io_attribute_validator.h new file mode 100644 index 000000000..5e38a5fef --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/io_attribute_validator.h @@ -0,0 +1,168 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_CORE_IR_IO_ATTRIBUTE_VALIDATOR_H_ +#define SRC_TINT_LANG_CORE_IR_IO_ATTRIBUTE_VALIDATOR_H_ + +#include + +#include "src/tint/lang/core/enums.h" +#include "src/tint/lang/core/io_attributes.h" +#include "src/tint/lang/core/ir/function.h" +#include "src/tint/lang/core/ir/module.h" +#include "src/tint/utils/containers/enum_set.h" +#include "src/tint/utils/containers/hashmap.h" +#include "src/tint/utils/containers/vector.h" + +namespace tint::core::ir::validator { + +/// The IO direction of an operation. +enum class IODirection : uint8_t { + kInput, + kOutput, + kResource, +}; +std::string_view ToString(IODirection value); + +/// The kind of shader IO being validated. +enum class ShaderIOKind : uint8_t { + kInputParam, + kResultValue, + kModuleScopeVar, +}; +std::string ToString(ShaderIOKind value); + +/// How an attribute is being used, a tuple of the shader stage and IO direction +enum class IOAttributeUsage : uint8_t { + kComputeInputUsage, + kComputeOutputUsage, + kComputeResourceUsage, + kFragmentInputUsage, + kFragmentOutputUsage, + kFragmentResourceUsage, + kVertexInputUsage, + kVertexOutputUsage, + kVertexResourceUsage, + kUndefinedUsage, +}; +std::string ToString(IOAttributeUsage value); + +/// Annotations that can be associated with a value that are used for shader IO, +/// e.g. binding_points, @location, being in workgroup address space, etc. +/// These are a subset of IOAttributes. +enum class IOAnnotation : uint8_t { + /// @group + @binding + kBindingPoint, + /// @location + kLocation, + /// @builtin(...) + kBuiltin, + /// Pointer to Workgroup address space + kWorkgroup, + /// @color + kColor, +}; +std::string ToString(IOAnnotation value); + +/// Adds appropriate entries to annotations, based on what values are present in attributes +/// @param annotations the set to updated +/// @param attr the attributes to be examined +/// @returns Success if none of the values being added where already present, otherwise returns the +/// first non-unique value as a Failure +Result AddIOAnnotationsFromIOAttributes( + EnumSet& annotations, + const IOAttributes& attr); + +/// @returns a human-readable string of all the entries in a EnumSet +template +std::string ToString(const EnumSet& values) { + std::stringstream result; + result << "[ "; + bool first = true; + for (auto v : values) { + if (!first) { + result << ", "; + } + first = false; + result << ToString(v); + } + result << " ]"; + return result.str(); +} + +/// State for validating IO attributes that needs to shared across impl invocations within the same +/// entry point. +struct IOAttributeContext { + Hashmap input_builtins; + Hashmap output_builtins; +}; + +/// IOAttributeChecker is the interface used to check that a usage of an IO attribute +/// meets the spec rules for a given context. +struct IOAttributeChecker { + /// What kinda of IO attribute is being checked + IOAttributeKind kind; + + /// What combination of stage and IO direction is this attribute legal for. + EnumSet valid_usages; + + /// What type of shader IO values is this attribute legal for. + EnumSet valid_io_kinds; + + /// Implements the validation logic for a specific attribute. + using CheckFn = Result(const core::type::Type* ty, + const IOAttributes& attr, + const Properties& prop, + IOAttributeUsage usage); + + /// The validation function. + CheckFn* const check; + + /// Implements logic for checking if the given type is valid or not. Is not a data entry (i.e. a + /// type or set of types), because types are part of the IR module and created at runtime. + using TypeCheckFn = bool(const core::type::Type* type, const Properties& props); + + /// @see #TypeCheckFn + TypeCheckFn* const type_check; + + /// Message for logging if the type check fails. Cannot be easily generated at runtime, because + /// the type check is a function, not just a data entry. + const char* type_error; +}; + +/// @returns all the appropriate IOAttributeCheckers for @p attr +Vector IOAttributeCheckersFor(const IOAttributes& attr, + bool skip_builtin); +/// @returns the IOAttributeUsage for a given Function::PipelineStage + IODirection tuple +IOAttributeUsage IOAttributeUsageFor(Function::PipelineStage stage, IODirection direction); + +/// @returns the IODirection for an AddressSpace +IODirection IODirectionFor(AddressSpace address_space); + +} // namespace tint::core::ir::validator + +#endif // SRC_TINT_LANG_CORE_IR_IO_ATTRIBUTE_VALIDATOR_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/loop.cc b/3rdparty/dawn/src/tint/lang/core/ir/loop.cc index 20cb75aac..6c74181ce 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/loop.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/loop.cc @@ -43,6 +43,7 @@ Loop::Loop(Id id, ir::Block* i, ir::MultiInBlock* b, ir::MultiInBlock* c) TINT_ASSERT(initializer_); TINT_ASSERT(body_); TINT_ASSERT(continuing_); + TINT_ASSERT(!initializer_->Is()); if (initializer_) { initializer_->SetParent(this); @@ -58,7 +59,7 @@ Loop::Loop(Id id, ir::Block* i, ir::MultiInBlock* b, ir::MultiInBlock* c) Loop::~Loop() = default; Loop* Loop::Clone(CloneContext& ctx) { - auto* new_init = ctx.ir.blocks.Create(); + auto* new_init = ctx.ir.blocks.Create(); auto* new_body = ctx.ir.blocks.Create(); auto* new_continuing = ctx.ir.blocks.Create(); @@ -103,6 +104,7 @@ bool Loop::HasInitializer() const { } void Loop::SetInitializer(ir::Block* block) { + TINT_ASSERT(!block || !block->Is()); if (initializer_ && initializer_->Parent() == this) { initializer_->SetParent(nullptr); } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/loop.h b/3rdparty/dawn/src/tint/lang/core/ir/loop.h index f8374b98f..89476bf5f 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/loop.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/loop.h @@ -77,7 +77,7 @@ class Loop final : public Castable { /// Constructor /// @param id the instruction id - /// @param i the initializer block + /// @param i the initializer block. Must not be a MultiInBlock. /// @param b the body block /// @param c the continuing block Loop(Id id, ir::Block* i, ir::MultiInBlock* b, ir::MultiInBlock* c); @@ -92,39 +92,39 @@ class Loop final : public Castable { /// @copydoc ControlInstruction::ForeachBlock void ForeachBlock(const std::function& cb) const override; - /// @returns the switch initializer block + /// @returns the loop initializer block ir::Block* Initializer() { return initializer_; } - /// @returns the switch initializer block + /// @returns the loop initializer block const ir::Block* Initializer() const { return initializer_; } /// @returns true if the loop uses an initializer block. If true, then the Loop first branches /// to the initializer block, otherwise it first branches to the body block. bool HasInitializer() const; - /// @param block the new switch initializer block + /// @param block the new loop initializer block. Must not be a MultiInBlock. void SetInitializer(ir::Block* block); - /// @returns the switch start block + /// @returns the loop start block ir::MultiInBlock* Body() { return body_; } - /// @returns the switch start block + /// @returns the loop start block const ir::MultiInBlock* Body() const { return body_; } - /// @param block the new switch body block + /// @param block the new loop body block void SetBody(ir::MultiInBlock* block); - /// @returns the switch continuing block + /// @returns the loop continuing block ir::MultiInBlock* Continuing() { return continuing_; } - /// @returns the switch continuing block + /// @returns the loop continuing block const ir::MultiInBlock* Continuing() const { return continuing_; } /// @returns true if the loop uses an continuing block. If true, then the Loop first branches /// to the continuing block, otherwise it first branches to the body block. bool HasContinuing() const; - /// @param block the new switch continuing block + /// @param block the new loop continuing block void SetContinuing(ir::MultiInBlock* block); /// @returns the friendly name for the instruction diff --git a/3rdparty/dawn/src/tint/lang/core/ir/module.h b/3rdparty/dawn/src/tint/lang/core/ir/module.h index ce9949291..c1375bfbb 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/module.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/module.h @@ -37,6 +37,7 @@ #include "src/tint/lang/core/ir/instruction.h" #include "src/tint/lang/core/ir/value.h" #include "src/tint/lang/core/type/manager.h" +#include "src/tint/utils/containers/enum_set.h" #include "src/tint/utils/containers/filtered_iterator.h" #include "src/tint/utils/containers/vector.h" #include "src/tint/utils/diagnostic/source.h" @@ -51,6 +52,89 @@ namespace tint::core::ir { #define TINT_IR_UNIMPLEMENTED(module) TINT_UNIMPLEMENTED(module.ice_callback) #define TINT_IR_ASSERT(module, condition) TINT_ASSERT((condition), module.ice_callback) +/// Enumerator of IR properties which can either add or subtract functionality from the core IR. +/// The IR validator will reject use of any non-core IR functionality when the module does not +/// contain the corresponding property. +enum class Property : uint8_t { + /// Allows 8-bit integer types to be used. + kAllow8BitIntegers, + /// Allows input_attachment_index to be associated with any type + kAllowAnyInputAttachmentIndexType, + /// Allows lets to have any type. + kAllowAnyLetType, + /// Allows ClipDistances on f32 and vecN parameters + kAllowClipDistancesOnF32ScalarAndVector, + /// Allows binding points to be non-unique. + kAllowDuplicateBindings, + /// Allows @location on structs, matrices, and arrays that have numeric elements + kAllowLocationForNumericComposites, + /// Allows module scoped lets + kAllowModuleScopeLets, + /// Allows MSL specific entry point interface variance. + kAllowMslEntryPointInterface, + /// Allows multiple entry points in the module. + kAllowMultipleEntryPoints, + /// Allows non-core types to be used. + kAllowNonCoreTypes, + /// Allow overrides + kAllowOverrides, + /// Allows phony assignment instructions to be used. + kAllowPhonyInstructions, + /// Allows the PointSize builtin to be used. + kAllowPointSizeBuiltin, + /// Allows a pointer to a handle type + kAllowPointerToHandle, + /// Allows reference types in the IR + kAllowRefTypes, + /// Allows matrix annotations on structure members. + kAllowStructMatrixDecorations, + /// Allows module scope `var`s to exist without an IO annotation. + kAllowUnannotatedModuleIOVariables, + /// Allows access instructions to create pointers to vector elements. + kAllowVectorElementPointer, + + /// Disallow use of the min/max/clamp builtins with vector types. + kDisallowVectorMinMaxClamp, +}; + +/// Properties is a set of Property values. +using Properties = EnumSet; + +/// Prints the Property @p p to @p o +/// @param o the stream to write to +/// @param p the Property +/// @return the stream so calls can be chained +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, Property p) { +#define CASE(p) \ + case Property::k##p: \ + return out << #p + switch (p) { // + CASE(Allow8BitIntegers); + CASE(AllowAnyInputAttachmentIndexType); + CASE(AllowAnyLetType); + CASE(AllowClipDistancesOnF32ScalarAndVector); + CASE(AllowDuplicateBindings); + CASE(AllowLocationForNumericComposites); + CASE(AllowModuleScopeLets); + CASE(AllowMslEntryPointInterface); + CASE(AllowMultipleEntryPoints); + CASE(AllowNonCoreTypes); + CASE(AllowOverrides); + CASE(AllowPhonyInstructions); + CASE(AllowPointSizeBuiltin); + CASE(AllowPointerToHandle); + CASE(AllowRefTypes); + CASE(AllowStructMatrixDecorations); + CASE(AllowUnannotatedModuleIOVariables); + CASE(AllowVectorElementPointer); + CASE(DisallowVectorMinMaxClamp); + } +#undef CASE + return out << ""; +} + /// Main module class for the IR. class Module { /// Map of value to name @@ -183,6 +267,9 @@ class Module { /// @param func the function to destroy void Destroy(Function* func); + /// The set of properties used by the module. + Properties properties; + /// The block allocator BlockAllocator blocks; @@ -201,6 +288,12 @@ class Module { /// The map of core::constant::Value to their ir::Constant. Hashmap constants; + /// If true, the AssertValid*() methods will perform validation. + bool enable_validation_asserts = false; + + /// If true, dump the IR whenever validation is performed. + bool dump_ir_when_validating = false; + /// An optional callback to receive an ICE generated while processing this module. InternalCompilerErrorCallback ice_callback; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/next_iteration.cc b/3rdparty/dawn/src/tint/lang/core/ir/next_iteration.cc index 425f505d2..10c0242b7 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/next_iteration.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/next_iteration.cc @@ -58,7 +58,7 @@ void NextIteration::Destroy() { if (loop_) { loop_->Body()->RemoveInboundSiblingBranch(this); } - Instruction::Destroy(); + Base::Destroy(); } NextIteration* NextIteration::Clone(CloneContext& ctx) { diff --git a/3rdparty/dawn/src/tint/lang/core/ir/operand_instruction.h b/3rdparty/dawn/src/tint/lang/core/ir/operand_instruction.h index c413a0215..8cf52438d 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/operand_instruction.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/operand_instruction.h @@ -132,10 +132,10 @@ class OperandInstruction : public Castable, Instruction /// Sets the results of the instruction /// @param values the new result values - template >>>> - void SetResults(ARGS&&... values) { + template + void SetResults(ARGS&&... values) + requires(!tint::IsVectorLike>>) + { SetResults(Vector{std::forward(values)...}); } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/referenced_functions.h b/3rdparty/dawn/src/tint/lang/core/ir/referenced_functions.h index 3af65546f..cab580bb6 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/referenced_functions.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/referenced_functions.h @@ -33,7 +33,6 @@ #include "src/tint/lang/core/ir/return.h" #include "src/tint/lang/core/ir/user_call.h" #include "src/tint/utils/containers/hashmap.h" -#include "src/tint/utils/rtti/switch.h" /// Utility that helps guarantee the same const-ness is applied to both types. template diff --git a/3rdparty/dawn/src/tint/lang/core/ir/referenced_module_decls.h b/3rdparty/dawn/src/tint/lang/core/ir/referenced_module_decls.h index 0e43ccd31..c31289037 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/referenced_module_decls.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/referenced_module_decls.h @@ -117,10 +117,16 @@ class ReferencedModuleDecls { continue; } auto* ary = ptr->UnwrapPtr()->template As(); - if (!ary) { + auto* buf = ptr->UnwrapPtr()->template As(); + if (!ary && !buf) { continue; } - auto* cnt = ary->Count()->template As(); + const core::ir::type::ValueArrayCount* cnt = nullptr; + if (ary) { + cnt = ary->Count()->template As(); + } else if (buf) { + cnt = buf->Count()->template As(); + } if (!cnt || cnt->value->template Is()) { continue; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/reflection.cc b/3rdparty/dawn/src/tint/lang/core/ir/reflection.cc index 35d71073d..87fa48c97 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/reflection.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/reflection.cc @@ -50,7 +50,7 @@ Result GetWorkgroupInfo(core::ir::Module& ir) { return Failure{"IR GetWorkgroupInfo: Could not find workgroup size"}; } - size_t wg_storage_size = 0u; + uint64_t wg_storage_size = 0u; for (auto* inst : *ir.root_block) { if (auto* as_var = inst->As()) { auto* ptr = as_var->Result()->Type()->As(); @@ -58,12 +58,13 @@ Result GetWorkgroupInfo(core::ir::Module& ir) { continue; } auto* ty = ptr->StoreType(); - uint32_t align = ty->Align(); - uint32_t size = ty->Size(); + uint64_t align = ty->Align(); + uint64_t size = ty->Size(); // This essentially matches std430 layout rules from GLSL, which are in // turn specified as an upper bound for Vulkan layout sizing. - wg_storage_size += tint::RoundUp(16u, tint::RoundUp(align, size)); + wg_storage_size += + tint::RoundUp(static_cast(16u), tint::RoundUp(align, size)); } } return WorkgroupInfo{(*const_wg_size)[0], (*const_wg_size)[1], (*const_wg_size)[2], diff --git a/3rdparty/dawn/src/tint/lang/core/ir/structural_validator.cc b/3rdparty/dawn/src/tint/lang/core/ir/structural_validator.cc new file mode 100644 index 000000000..92bbd4a7b --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/structural_validator.cc @@ -0,0 +1,2970 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/tint/lang/core/ir/structural_validator.h" + +#include +#include + +#include "src/tint/lang/core/binary_op.h" +#include "src/tint/lang/core/intrinsic/table.h" +#include "src/tint/lang/core/ir/constant.h" +#include "src/tint/lang/core/ir/constexpr_if.h" +#include "src/tint/lang/core/ir/core_binary.h" +#include "src/tint/lang/core/ir/multi_in_block.h" +#include "src/tint/lang/core/ir/referenced_functions.h" +#include "src/tint/lang/core/ir/terminate_invocation.h" +#include "src/tint/lang/core/ir/unused.h" +#include "src/tint/lang/core/type/array.h" +#include "src/tint/lang/core/type/array_count.h" +#include "src/tint/lang/core/type/binding_array.h" +#include "src/tint/lang/core/type/bool.h" +#include "src/tint/lang/core/type/buffer.h" +#include "src/tint/lang/core/type/f16.h" +#include "src/tint/lang/core/type/f32.h" +#include "src/tint/lang/core/type/function.h" +#include "src/tint/lang/core/type/i32.h" +#include "src/tint/lang/core/type/i8.h" +#include "src/tint/lang/core/type/matrix.h" +#include "src/tint/lang/core/type/memory_view.h" +#include "src/tint/lang/core/type/pointer.h" +#include "src/tint/lang/core/type/reference.h" +#include "src/tint/lang/core/type/sampled_texture.h" +#include "src/tint/lang/core/type/storage_texture.h" +#include "src/tint/lang/core/type/subgroup_matrix.h" +#include "src/tint/lang/core/type/u16.h" +#include "src/tint/lang/core/type/u32.h" +#include "src/tint/lang/core/type/u64.h" +#include "src/tint/lang/core/type/u8.h" +#include "src/tint/lang/core/type/vector.h" +#include "src/tint/lang/core/type/void.h" +#include "src/tint/utils/containers/predicates.h" +#include "src/tint/utils/containers/reverse.h" +#include "src/tint/utils/containers/transform.h" +#include "src/tint/utils/ice/ice.h" +#include "src/tint/utils/macros/defer.h" +#include "src/tint/utils/math/math.h" +#include "src/tint/utils/result.h" +#include "src/tint/utils/rtti/switch.h" +#include "src/tint/utils/text/text_style.h" + +namespace tint::core::ir::validator { +namespace { + +/// @returns the parent block of @p block +const Block* ParentBlockOf(const Block* block) { + if (auto* parent = block->Parent()) { + return parent->Block(); + } + return nullptr; +} + +/// @returns true if @p block directly or transitively holds the instruction @p inst +bool TransitivelyHolds(const Block* block, const Instruction* inst) { + for (auto* b = inst->Block(); b; b = ParentBlockOf(b)) { + if (b == block) { + return true; + } + } + return false; +} + +/// @returns true if @p type is in the core namespace +bool IsCoreType(const core::type::Type* type) { + return std::string_view(type->TypeInfo().name).starts_with("tint::core"); +} + +/// @returns true if @p ty is a non-struct and decorated with @builtin(position), or if it is a +/// struct and one of its members is decorated, otherwise false. +/// @param attr attributes attached to data +/// @param ty type of the data being tested +bool IsPositionPresent(const IOAttributes& attr, const core::type::Type* ty) { + if (auto* ty_struct = ty->As()) { + for (const auto* mem : ty_struct->Members()) { + if (mem->Attributes().builtin == BuiltinValue::kPosition) { + return true; + } + } + return false; + } + + return attr.builtin == BuiltinValue::kPosition; +} + +template +void WalkTypeAndMembers(CTX& ctx, + const core::type::Type* type, + const IOAttributes& attr, + IMPL&& impl); +/// Helper that walks the members of a struct, called from WalkTypeAndMembers and its helpers +/// @param ctx a context object to pass to the impl function +/// @param str the struct to walk the members of +/// @param impl an impl function to be run, see WalkTypeAndMembers for details +template +void WalkStructMembers(CTX& ctx, const core::type::Struct* str, IMPL&& impl) { + for (auto* member : str->Members()) { + WalkTypeAndMembers(ctx, member->Type(), member->Attributes(), impl); + } +} + +/// Helper that walks an array's element type, called from WalkTypeAndMembers and its helpers +/// @param ctx a context object to pass to the impl function +/// @param arr the array to walk the element type of +/// @param impl an impl function to be run, see WalkTypeAndMembers for details +template +void WalkArrayElements(CTX& ctx, const core::type::Array* arr, IMPL&& impl) { + WalkTypeAndMembers(ctx, arr->ElemType(), IOAttributes{}, impl); +} + +/// Helper for walking a type that maybe a struct, calling an impl function for the type and each of +/// its members. +/// @param ctx a context object to pass to the implementation function +/// @param type the type to walk +/// @param attr the attributes for @p type +/// @param impl a function with the signature `void(const core::type::Type*, const IOAttributes&, +/// CTX&)` that is called for each type. +template +void WalkTypeAndMembers(CTX& ctx, + const core::type::Type* type, + const IOAttributes& attr, + IMPL&& impl) { + impl(ctx, type, attr); + tint::Switch( + type, [&](const core::type::Struct* s) { WalkStructMembers(ctx, s, impl); }, + [&](const core::type::Array* a) { WalkArrayElements(ctx, a, impl); }); +} + +} // namespace + +Structural::Structural(const Module& ir, diag::List& diagnostics, Capabilities capabilities) + : ir_(ir), diag_(diagnostics), capabilities_(capabilities), referenced_module_vars_(ir) {} + +Structural::~Structural() = default; + +Disassembler& Structural::Disassemble() { + if (!disassembler_) { + disassembler_.emplace(ir::Disassembler(ir_)); + } + return *disassembler_; +} + +void Structural::Validate() { + RunStructuralSoundnessChecks(); + + CheckForRecursion(); + CheckForOrphanedInstructions(); + CheckStageRestrictedInstructions(); +} + +void Structural::CheckForRecursion() { + if (diag_.ContainsErrors()) { + return; + } + + ReferencedFunctions referenced_functions(ir_); + for (auto& func : ir_.functions) { + auto& refs = referenced_functions.TransitiveReferences(func); + if (refs.Contains(func)) { + // TODO(434684891): Consider improving this error with more information. + AddError(func) << "recursive function calls are not allowed"; + return; + } + } +} + +void Structural::CheckForOrphanedInstructions() { + if (diag_.ContainsErrors()) { + return; + } + + // Check for orphaned instructions. + for (auto* inst : ir_.Instructions()) { + if (!visited_instructions_.Contains(inst)) { + AddError(inst) << "orphaned instruction: " << inst->FriendlyName(); + } + } +} + +void Structural::CheckStageRestrictedInstructions() { + if (diag_.ContainsErrors()) { + return; + } + + // Check for instructions being used in stages that do not support them. + for (const auto& i : stage_restricted_instructions_) { + const auto& inst = i.key; + const auto& stages = i.value; + const auto* f = ContainingFunction(inst); + if (f == nullptr) { + continue; + } + + if (f->IsEntryPoint() && !stages.Contains(f->Stage())) { + AddError(inst) << "cannot be used in a " << f->Stage() << " shader"; + } else { + for (const Function* ep : ContainingEndPoints(f)) { + if (!stages.Contains(ep->Stage())) { + AddError(inst) << "cannot be used in a " << ep->Stage() << " shader"; + } + } + } + } +} + +void Structural::RunStructuralSoundnessChecks() { + scope_stack_.Push(); + TINT_DEFER({ + scope_stack_.Pop(); + TINT_ASSERT(scope_stack_.IsEmpty()); + TINT_ASSERT(tasks_.IsEmpty()); + TINT_ASSERT(control_stack_.IsEmpty()); + TINT_ASSERT(block_stack_.IsEmpty()); + }); + CheckRootBlock(ir_.root_block); + + for (auto& func : ir_.functions) { + if (!all_functions_.Add(func)) { + AddError(func) << "function " << NameOf(func) << " added to module multiple times"; + } + scope_stack_.Add(func); + } + + for (auto& func : ir_.functions) { + block_to_function_.Add(func->Block(), func); + CheckFunction(func); + } +} + +diag::Diagnostic& Structural::AddError(const Instruction* inst) { + auto src = Disassemble().InstructionSource(inst); + auto& diag = AddError(src) << inst->FriendlyName() << ": "; + + if (!block_stack_.IsEmpty()) { + AddNote(block_stack_.Back()) << "in block"; + + // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we + // need to get a new reference to the error diagnostic here. + return *(diag_.end() - 2); + } + return diag; +} + +diag::Diagnostic& Structural::AddError(const Instruction* inst, size_t idx) { + auto src = + Disassemble().OperandSource(Disassembler::IndexedValue{inst, static_cast(idx)}); + auto& diag = AddError(src) << inst->FriendlyName() << ": "; + + if (!block_stack_.IsEmpty()) { + AddNote(block_stack_.Back()) << "in block"; + + // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we + // need to get a new reference to the error diagnostic here. + return *(diag_.end() - 2); + } + return diag; +} + +diag::Diagnostic& Structural::AddResultError(const Instruction* inst, size_t idx) { + auto src = + Disassemble().ResultSource(Disassembler::IndexedValue{inst, static_cast(idx)}); + auto& diag = AddError(src) << inst->FriendlyName() << ": "; + + if (!block_stack_.IsEmpty()) { + AddNote(block_stack_.Back()) << "in block"; + + // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we + // need to get a new reference to the error diagnostic here. + return *(diag_.end() - 2); + } + return diag; +} + +diag::Diagnostic& Structural::AddError(const Block* blk) { + auto src = Disassemble().BlockSource(blk); + return AddError(src); +} + +diag::Diagnostic& Structural::AddError(const BlockParam* param) { + auto src = Disassemble().BlockParamSource(param); + return AddError(src); +} + +diag::Diagnostic& Structural::AddError(const Function* func) { + auto src = Disassemble().FunctionSource(func); + return AddError(src); +} + +diag::Diagnostic& Structural::AddError(const FunctionParam* param) { + auto src = Disassemble().FunctionParamSource(param); + return AddError(src); +} + +diag::Diagnostic& Structural::AddError(const CastableBase* base) { + diag::Diagnostic* diag = nullptr; + tint::Switch( + base, // + [&](const Block* block) { diag = &AddError(block); }, + [&](const BlockParam* param) { diag = &AddError(param); }, + [&](const Function* fn) { diag = &AddError(fn); }, + [&](const FunctionParam* param) { diag = &AddError(param); }, + [&](const Instruction* inst) { diag = &AddError(inst); }, + [&](const InstructionResult* res) { diag = &AddError(res); }); + TINT_ASSERT(diag); + return *diag; +} + +diag::Diagnostic& Structural::AddNote(const Instruction* inst) { + auto src = Disassemble().InstructionSource(inst); + return AddNote(src); +} + +diag::Diagnostic& Structural::AddNote(const Function* func) { + auto src = Disassemble().FunctionSource(func); + return AddNote(src); +} + +diag::Diagnostic& Structural::AddOperandNote(const Instruction* inst, size_t idx) { + auto src = + Disassemble().OperandSource(Disassembler::IndexedValue{inst, static_cast(idx)}); + return AddNote(src); +} + +diag::Diagnostic& Structural::AddResultNote(const Instruction* inst, size_t idx) { + auto src = + Disassemble().ResultSource(Disassembler::IndexedValue{inst, static_cast(idx)}); + return AddNote(src); +} + +diag::Diagnostic& Structural::AddNote(const Block* blk) { + auto src = Disassemble().BlockSource(blk); + return AddNote(src); +} + +diag::Diagnostic& Structural::AddError(Source src) { + auto& diag = diag_.AddError(src); + diag.owned_file = Disassemble().File(); + return diag; +} + +diag::Diagnostic& Structural::AddNote(Source src) { + auto& diag = diag_.AddNote(src); + diag.owned_file = Disassemble().File(); + return diag; +} + +void Structural::AddDeclarationNote(const CastableBase* decl) { + tint::Switch( + decl, // + [&](const Block* block) { AddDeclarationNote(block); }, + [&](const BlockParam* param) { AddDeclarationNote(param); }, + [&](const Function* fn) { AddDeclarationNote(fn); }, + [&](const FunctionParam* param) { AddDeclarationNote(param); }, + [&](const Instruction* inst) { AddDeclarationNote(inst); }, + [&](const InstructionResult* res) { AddDeclarationNote(res); }); +} + +void Structural::AddDeclarationNote(const Block* block) { + auto src = Disassemble().BlockSource(block); + if (src.file) { + AddNote(src) << NameOf(block) << " declared here"; + } +} + +void Structural::AddDeclarationNote(const BlockParam* param) { + auto src = Disassemble().BlockParamSource(param); + if (src.file) { + AddNote(src) << NameOf(param) << " declared here"; + } +} + +void Structural::AddDeclarationNote(const Function* fn) { + AddNote(fn) << NameOf(fn) << " declared here"; +} + +void Structural::AddDeclarationNote(const FunctionParam* param) { + auto src = Disassemble().FunctionParamSource(param); + if (src.file) { + AddNote(src) << NameOf(param) << " declared here"; + } +} + +void Structural::AddDeclarationNote(const Instruction* inst) { + auto src = Disassemble().InstructionSource(inst); + if (src.file) { + AddNote(src) << NameOf(inst) << " declared here"; + } +} + +void Structural::AddDeclarationNote(const InstructionResult* res) { + if (auto* inst = res->Instruction()) { + auto results = inst->Results(); + for (size_t i = 0; i < results.Length(); i++) { + if (results[i] == res) { + AddResultNote(res->Instruction(), i) << NameOf(res) << " declared here"; + return; + } + } + } +} + +StyledText Structural::NameOf(const CastableBase* decl) { + return tint::Switch( + decl, // + [&](const core::type::Type* ty) { return NameOf(ty); }, + [&](const Value* value) { return NameOf(value); }, + [&](const Instruction* inst) { return NameOf(inst); }, + [&](const Block* block) { return NameOf(block); }, // + TINT_ICE_ON_NO_MATCH); +} + +StyledText Structural::NameOf(const core::type::Type* ty) { + auto name = ty ? ty->FriendlyName() : "undef"; + return StyledText{} << style::Type(name); +} + +StyledText Structural::NameOf(const Value* value) { + return Disassemble().NameOf(value); +} + +StyledText Structural::NameOf(const Instruction* inst) { + auto name = inst ? inst->FriendlyName() : "undef"; + return StyledText{} << style::Instruction(name); +} + +StyledText Structural::NameOf(const Block* block) { + auto parent_name = block->Parent() ? block->Parent()->FriendlyName() : "undef"; + return StyledText{} << style::Instruction(parent_name) << " block " + << Disassemble().NameOf(block); +} + +bool Structural::CheckResult(const Instruction* inst, size_t idx) { + auto* result = inst->Result(idx); + if (DAWN_UNLIKELY(result == nullptr)) { + AddResultError(inst, idx) << "result is undefined"; + return false; + } + + if (DAWN_UNLIKELY(result->Type() == nullptr)) { + AddResultError(inst, idx) << "result type is undefined"; + return false; + } + + if (DAWN_UNLIKELY(result->Instruction() == nullptr)) { + AddResultError(inst, idx) << "result instruction is undefined"; + return false; + } + + if (DAWN_UNLIKELY(result->Instruction() != inst)) { + AddResultError(inst, idx) + << "result instruction does not match instruction (possible double usage)"; + return false; + } + + if (!inst->Is() && result->Type()->Is()) { + AddResultError(inst, idx) << "result type cannot be void"; + return false; + } + + if (inst->Is()) { + if (result->Type()->Is()) { + AddResultError(inst, idx) << "result type cannot be a pointer"; + return false; + } + if (!result->Type()->IsConstructible()) { + AddResultError(inst, idx) << "result type must be constructable"; + return false; + } + } + + if (result->Type()->Is() && ir_.NameOf(result)) { + AddResultError(inst, idx) << "void results must not have names"; + return false; + } + + return true; +} + +bool Structural::CheckResults(const ir::Instruction* inst, std::optional count = {}) { + if (count.has_value()) { + if (DAWN_UNLIKELY(inst->Results().Length() != count.value())) { + AddError(inst) << "expected exactly " << count.value() << " results, got " + << inst->Results().Length(); + return false; + } + } + + bool passed = true; + Hashset seen_instruction_results; + for (size_t i = 0; i < inst->Results().Length(); i++) { + if (DAWN_UNLIKELY(!CheckResult(inst, i))) { + passed = false; + } + + if (!seen_instruction_results.Add(inst->Result(i))) { + AddResultError(inst, i) << "result was seen previously as a result"; + passed = false; + } + } + return passed; +} + +bool Structural::CheckOperand(const Instruction* inst, size_t idx) { + auto* operand = inst->Operand(idx); + + if (DAWN_UNLIKELY(operand == nullptr)) { + // var instructions are allowed to have a nullptr initializers. + // terminator instructions use nullptr operands to signal 'undef'. + if (inst->IsAnyOf()) { + return true; + } + + AddError(inst, idx) << "operand is undefined"; + return false; + } + + // ir::Unused is a internal value used by some transforms to track unused entries, and is + // removed as part of generating an output shader. + if (DAWN_UNLIKELY(operand->Is())) { + return true; + } + + if (DAWN_UNLIKELY(operand->Type() == nullptr)) { + AddError(inst, idx) << "operand type is undefined"; + return false; + } + + if (DAWN_UNLIKELY(!operand->Alive())) { + AddError(inst, idx) << "operand is not alive"; + return false; + } + + if (DAWN_UNLIKELY(operand->Is() && + operand->Type()->Is())) { + AddError(inst, idx) << "subgroup_matrix values cannot be constant"; + return false; + } + + if (DAWN_UNLIKELY(!operand->HasUsage(inst, idx))) { + AddError(inst, idx) << "operand missing usage"; + return false; + } + + if (auto fn = operand->As(); fn && !all_functions_.Contains(fn)) { + AddError(inst, idx) << NameOf(operand) << " is not part of the module"; + return false; + } + + if (DAWN_UNLIKELY(!operand->Is() && !operand->Is() && + !scope_stack_.Contains(operand))) { + AddError(inst, idx) << NameOf(operand) << " is not in scope"; + AddDeclarationNote(operand); + return false; + } + + return true; +} + +bool Structural::CheckOperands(const ir::Instruction* inst, + size_t min_count, + std::optional max_count) { + if (DAWN_UNLIKELY(inst->Operands().Length() < min_count)) { + if (max_count.has_value()) { + AddError(inst) << "expected between " << min_count << " and " << max_count.value() + << " operands, got " << inst->Operands().Length(); + } else { + AddError(inst) << "expected at least " << min_count << " operands, got " + << inst->Operands().Length(); + } + return false; + } + + if (DAWN_UNLIKELY(max_count.has_value() && inst->Operands().Length() > max_count.value())) { + AddError(inst) << "expected between " << min_count << " and " << max_count.value() + << " operands, got " << inst->Operands().Length(); + return false; + } + + bool passed = true; + for (size_t i = 0; i < inst->Operands().Length(); i++) { + if (DAWN_UNLIKELY(!CheckOperand(inst, i))) { + passed = false; + } + } + return passed; +} + +bool Structural::CheckOperands(const ir::Instruction* inst, std::optional count = {}) { + if (count.has_value()) { + if (DAWN_UNLIKELY(inst->Operands().Length() != count.value())) { + AddError(inst) << "expected exactly " << count.value() << " operands, got " + << inst->Operands().Length(); + return false; + } + } + + bool passed = true; + for (size_t i = 0; i < inst->Operands().Length(); i++) { + if (DAWN_UNLIKELY(!CheckOperand(inst, i))) { + passed = false; + } + } + return passed; +} + +bool Structural::CheckResultsAndOperandRange(const ir::Instruction* inst, + size_t num_results, + size_t min_operands, + std::optional max_operands = {}) { + // Intentionally avoiding short-circuiting here + bool results_passed = CheckResults(inst, num_results); + bool operands_passed = CheckOperands(inst, min_operands, max_operands); + return results_passed && operands_passed; +} + +bool Structural::CheckResultsAndOperands(const ir::Instruction* inst, + size_t num_results, + size_t num_operands) { + // Intentionally avoiding short-circuiting here + bool results_passed = CheckResults(inst, num_results); + bool operands_passed = CheckOperands(inst, num_operands); + return results_passed && operands_passed; +} + +void Structural::CheckType(const core::type::Type* root, + std::function diag, + Capabilities allow_caps) { + if (root == nullptr) { + return; + } + + if (!ir_.properties.Contains(Property::kAllowNonCoreTypes)) { + if (!IsCoreType(root)) { + diag() << "non-core types not allowed in core IR"; + return; + } + } + + if (!validated_types_.Add(root)) { + return; + } + + AddressSpace addrspace = AddressSpace::kUndefined; + if (auto* mv = root->As()) { + addrspace = mv->AddressSpace(); + } + + auto visit = [&](const core::type::Type* type, const core::type::Type* parent) { + if (type->IsAbstract()) { + diag() << "abstracts are not permitted"; + return false; + } + + return tint::Switch( + type, + [&](const core::type::Struct* str) { + uint32_t cur_offset = 0; + for (auto* member : str->Members()) { + if (member->Type()->Is()) { + diag() << "struct member " << member->Index() << " cannot have void type"; + return false; + } + + if (!CheckStructMemberAttributes(member, diag)) { + return false; + } + + if (!ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + if (member->Type()->Is()) { + diag() << "struct member " << member->Index() + << " cannot be a pointer type"; + return false; + } + + if (member->Type()->Is()) { + diag() << "struct member " << member->Index() + << " cannot be a texture type"; + return false; + } + + if (member->Type()->Is()) { + diag() << "struct member " << member->Index() + << " cannot be a sampler type"; + return false; + } + } + + if (auto* arr = member->Type()->As(); + arr && arr->Count()->Is()) { + if (member != str->Members().Back()) { + diag() << "runtime-sized arrays can only be the last member of a " + "struct"; + return false; + } + } + + if (member->Align() == 0) { + diag() << "struct member must not have an alignment of 0"; + return false; + } + if (!tint::IsPowerOfTwo(member->Align())) { + diag() << "struct member alignment must be a power of 2"; + return false; + } + + if (member->Type()->Align() == 0) { + diag() << "struct member type must not have an alignment of 0"; + return false; + } + if (!tint::IsPowerOfTwo(member->Type()->Align())) { + diag() << "struct member type alignment must be a power of 2"; + return false; + } + if (!ir_.properties.Contains(Property::kAllowStructMatrixDecorations)) { + if (member->RowMajor()) { + diag() << "Row major annotation not allowed on structures"; + return false; + } + if (member->HasMatrixStride()) { + diag() << "Matrix stride annotation not allowed on structures"; + return false; + } + } + + // TODO(448608979): Remove guard once updated to handle RowMajor correctly + if (!member->RowMajor()) { + if (member->Size() < member->Type()->Size()) { + diag() << "struct member " << member->Index() + << " with size=" << member->Size() + << " must be at least as large as the type with size " + << member->Type()->Size(); + return false; + } + + if (member->Align() % member->Type()->Align() != 0) { + diag() << "struct member alignment (" << member->Align() + << ") must be divisible by type alignment (" + << member->Type()->Align() << ")"; + return false; + } + } + + cur_offset += (member->Offset() - cur_offset) + member->MinimumRequiredSize(); + } + if (str->Size() < cur_offset) { + diag() << "struct size (" << str->Size() + << ") is smaller than the end of the last member (" << cur_offset << ")"; + return false; + } + + return true; + }, + [&](const core::type::Reference* ref) { + if (ref->StoreType()->Is()) { + diag() << "references to void are not permitted"; + return false; + } + + // Reference types are guarded by the AllowRefTypes property. + if (!ir_.properties.Contains(Property::kAllowRefTypes)) { + diag() << "reference types are not permitted here"; + return false; + } else if (type != root) { + // If they are allowed, reference types still cannot be nested. + diag() << "nested reference types are not permitted"; + return false; + } + return true; + }, + [&](const core::type::Pointer* ptr) { + if (ptr->StoreType()->Is()) { + diag() << "pointers to void are not permitted"; + return false; + } + + if (ptr->AddressSpace() == AddressSpace::kUniform || + ptr->AddressSpace() == AddressSpace::kHandle || + ptr->AddressSpace() == core::AddressSpace::kImmediate) { + if (ptr->Access() != core::Access::kRead) { + diag() << ToString(ptr->AddressSpace()) << " pointers must be read access"; + return false; + } + } + + if (ptr->AddressSpace() == AddressSpace::kWorkgroup || + ptr->AddressSpace() == AddressSpace::kFunction || + ptr->AddressSpace() == AddressSpace::kPrivate) { + if (ptr->Access() != core::Access::kReadWrite) { + diag() << ToString(ptr->AddressSpace()) + << " pointers must be read_write access"; + return false; + } + } + + if (ptr->AddressSpace() == AddressSpace::kHandle) { + if (!ptr->StoreType()->IsHandle()) { + diag() << "the 'handle' address space can only be used for handle types"; + return false; + } + } else { + if (ptr->StoreType()->IsHandle()) { + diag() << "handle types can only be declared in the 'handle' address space"; + return false; + } + } + + if (ptr->StoreType()->Is()) { + diag() << "pointers to pointers are not allowed"; + return false; + } + return true; + }, + [&](const core::type::U64*) { + // u64 types are guarded by the Allow64BitIntegers capability. + if (!capabilities_.Contains(Capability::kAllow64BitIntegers) && + !allow_caps.Contains(Capability::kAllow64BitIntegers)) { + diag() << "64-bit integer types are not permitted"; + return false; + } + return true; + }, + [&](const core::type::I8*) { + // General use of i8 types is guarded by the Allow8BitIntegers property. + // They can be used as the component type of a subgroup matrix without the property. + if (!Is(parent) && + !ir_.properties.Contains(Property::kAllow8BitIntegers)) { + diag() << "8-bit integer types are not permitted"; + return false; + } + return true; + }, + [&](const core::type::U8*) { + // General use of u8 types is guarded by the Allow8BitIntegers property. + // They can be used as the component type of a subgroup matrix without the property. + if (!Is(parent) && + !ir_.properties.Contains(Property::kAllow8BitIntegers)) { + diag() << "8-bit integer types are not permitted"; + return false; + } + return true; + }, + [&](const core::type::U16*) { + // u16 types are guarded by the Allow16BitIntegers capability. + if (!capabilities_.Contains(Capability::kAllow16BitIntegers)) { + diag() << "16-bit integer types are not permitted"; + return false; + } + return true; + }, + [&](const core::type::Array* arr) { + if (!arr->ElemType()->HasCreationFixedFootprint()) { + diag() << "array elements, " << NameOf(type) + << ", must have creation-fixed footprint"; + return false; + } + if (auto* count = arr->Count()->As()) { + if (count->value == 0) { + diag() << "array requires a constant array size > 0"; + return false; + } + } else if (auto* val_count = arr->Count()->As()) { + if (!val_count->value->Alive()) { + diag() << "ValueArrayCount value is not alive"; + return false; + } + if (!val_count->value->Type()->IsIntegerScalar()) { + diag() << "ValueArrayCount must be an integer scalar type"; + return false; + } + auto* inst_res = val_count->value->As(); + if (!inst_res) { + diag() << "ValueArrayCount must be an instruction result"; + return false; + } + auto* inst = inst_res->Instruction(); + if (!inst || inst->Block() != ir_.root_block) { + diag() << "ValueArrayCount must be a module-scoped override expression"; + return false; + } + } + return true; + }, + [&](const core::type::Vector* v) { + if (!v->Type()->IsScalar()) { + diag() << "vector elements, " << NameOf(type) << ", must be scalars"; + return false; + } + return true; + }, + [&](const core::type::Matrix* m) { + if (!m->Type()->IsFloatScalar()) { + diag() << "matrix elements, " << NameOf(type) << ", must be float scalars"; + return false; + } + return true; + }, + [&](const core::type::Atomic* a) { + // Prior to lowering we allow for atomic operations on vec2u to support the + // AtomicVec2UMinMax feature. + if (auto* vec = a->Type()->As()) { + if (vec->Width() == 2 && vec->Type()->Is()) { + return true; + } + } + + if (!a->Type()->IsAnyOf()) { + diag() << "atomic subtype must be i32, u32 or u64 type is " + << NameOf(a->Type()); + return false; + } + return true; + }, + [&](const core::type::SampledTexture* s) { + if (!s->Type()->IsAnyOf()) { + diag() << "invalid sampled texture sample type: " << NameOf(s->Type()); + return false; + } + return true; + }, + [&](const core::type::MultisampledTexture* ms) { + if (!ms->Type()->IsAnyOf()) { + diag() << "invalid multisampled texture sample type: " << NameOf(ms->Type()); + return false; + } + + switch (ms->Dim()) { + case core::type::TextureDimension::k2d: + break; + default: + diag() << "invalid multisampled texture dimension: " + << style::Literal(ToString(ms->Dim())); + return false; + } + return true; + }, + [&](const core::type::StorageTexture* s) { + switch (s->Dim()) { + case core::type::TextureDimension::kCube: + case core::type::TextureDimension::kCubeArray: + diag() << "dimension " << style::Literal(ToString(s->Dim())) + << " for storage textures does not in WGSL yet"; + return false; + case core::type::TextureDimension::kNone: + diag() << "invalid texture dimension " + << style::Literal(ToString(s->Dim())); + return false; + default: + return true; + } + }, + [&](const core::type::InputAttachment* i) { + if (!i->Type()->IsAnyOf()) { + diag() << "invalid input attachment component type: " << NameOf(i->Type()); + return false; + } + return true; + }, + [&](const core::type::SubgroupMatrix* m) { + if (!m->Type() + ->IsAnyOf()) { + diag() << "invalid subgroup matrix component type: " << NameOf(m->Type()); + return false; + } + if (!(addrspace == AddressSpace::kUndefined || + addrspace == AddressSpace::kFunction)) { + diag() << "invalid address space for subgroup matrix : " << addrspace; + return false; + } + return true; + }, + [&](const core::type::BindingArray* t) { + if (!t->Count()->Is()) { + diag() << "binding_array count must be a constant expression"; + return false; + } + + auto count = t->Count()->As()->value; + if (count == 0) { + diag() << "binding array requires a constant array size > 0"; + return false; + } + + if (!(addrspace == AddressSpace::kUndefined || + addrspace == AddressSpace::kHandle) && + !ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + diag() << "invalid address space for binding_array : " << addrspace; + return false; + } + + if (!ir_.properties.Contains(Property::kAllowNonCoreTypes)) { + if (!t->ElemType()->Is()) { + diag() << "binding_array element type must be a sampled texture type"; + return false; + } + } + return true; + }, + [](Default) { return true; }); + }; + + struct Pending { + const core::type::Type* type = nullptr; + const core::type::Type* parent = nullptr; + + bool operator==(const Pending& other) const { + return type == other.type && parent == other.parent; + } + + struct Hasher { + HashCode operator()(const Pending& p) const { + return HashCombine(Hash(p.type), Hash(p.parent)); + } + }; + }; + Vector stack{Pending{root, nullptr}}; + Hashset seen{}; + while (!stack.IsEmpty()) { + auto [ty, parent] = stack.Pop(); + if (!ty) { + continue; + } + if (!visit(ty, parent)) { + return; + } + + if (auto* view = ty->As()) { + Pending next{view->StoreType(), ty}; + if (seen.Add(next)) { + stack.Push(next); + } + continue; + } + + // Visit the elements of a composite type. + auto type_count = ty->Elements(); + if (type_count.type) { + // Every element has the same type (e.g. array, vector, matrix, ...), so validate that + // type once if it has not been seen before. + Pending next{type_count.type, ty}; + if (seen.Add(next)) { + stack.Push(next); + } + } else { + // Different elements have different types (e.g. a struct), so we need to validate each + // of them if they have not been seen before. + for (uint32_t i = 0; i < type_count.count; i++) { + if (auto* subtype = ty->Element(i)) { + Pending next{subtype, ty}; + if (seen.Add(next)) { + stack.Push(next); + } + } + } + } + } +} + +void Structural::CheckRootBlock(const Block* blk) { + block_stack_.Push(blk); + TINT_DEFER(block_stack_.Pop()); + + Hashset pipeline_evaluatable{}; + + auto add_evaluatable = [&](const Instruction* inst, const bool is_creatable) { + if (auto* res = inst->Result(0); res != nullptr && is_creatable) { + pipeline_evaluatable.Add(res); + } + }; + + for (auto* inst : *blk) { + if (inst->Block() != blk) { + AddError(inst) << "instruction in root block does not have root block as parent"; + continue; + } + + auto is_pipeline_creatable = true; + for (auto* op : inst->Operands()) { + if (!op) { + continue; + } + if (op->Is()) { + continue; + } + if (pipeline_evaluatable.Contains(op)) { + continue; + } + is_pipeline_creatable = false; + break; + } + + if (!is_pipeline_creatable) { + AddError(inst) << "instruction is not evaluatable at pipeline creation time"; + } + + tint::Switch( + inst, // + [&](const core::ir::Override* o) { + if (ir_.properties.Contains(Property::kAllowOverrides)) { + CheckInstruction(o); + add_evaluatable(o, is_pipeline_creatable); + } else { + AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; + } + }, + [&](const core::ir::Var* var) { CheckInstruction(var); }, + [&](const core::ir::Let* let) { + if (ir_.properties.Contains(Property::kAllowModuleScopeLets)) { + CheckInstruction(let); + add_evaluatable(let, is_pipeline_creatable); + } else { + AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; + } + }, + [&](const core::ir::Construct* c) { + if (ir_.properties.Contains(Property::kAllowModuleScopeLets) || + ir_.properties.Contains(Property::kAllowOverrides)) { + CheckInstruction(c); + CheckOnlyUsedInRootBlock(inst); + add_evaluatable(c, is_pipeline_creatable); + } else { + AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; + } + }, + [&](Default) { + // Note, this validation around kAllowOverrides is looser than it could be. There + // are only certain expressions and builtins which can be used in an override, which + // currently isn't checked. + if (ir_.properties.Contains(Property::kAllowOverrides) && + inst->IsAnyOf()) { + CheckInstruction(inst); + // If overrides are allowed we can have certain regular instructions in the root + // block, with the caveat that those instructions can _only_ be used in the root + // block. + CheckOnlyUsedInRootBlock(inst); + add_evaluatable(inst, is_pipeline_creatable); + } else { + AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; + } + }); + + // Process tasks queued by CheckInstruction (like AddResults) before moving to next + // instruction. + ProcessTasks(); + } +} + +void Structural::CheckOnlyUsedInRootBlock(const Instruction* inst) { + if (inst->Result(0)) { + for (auto& usage : inst->Result(0)->UsagesSorted()) { + if (usage.instruction->Block() != ir_.root_block) { + AddError(inst) << "root block: instruction used outside of root block " + << inst->TypeInfo().name; + } + } + } + + CheckInstruction(inst); +} + +void Structural::CheckFunction(const Function* func) { + // Scope holds the parameters and block + scope_stack_.Push(); + TINT_DEFER(scope_stack_.Pop()); + + // The recursion checks require this to be true as it will be asserted by the + // referenced_functions helper. + func->ForEachUseUnsorted([&](const Usage& use) { + if (use.instruction->As() || use.instruction->As()) { + return; + } + AddError(use.instruction, use.operand_index) << "function may not be used as a operand"; + }); + + if (!func->Type() || !func->Type()->Is()) { + AddError(func) << "functions must have type ''"; + return; + } + + // Note: This is not a validator error because Function::SetBlock() asserts that the block is + // not null, and the disassembler will crash if this is not null. This should only be hit due + // to some sort of corruption, not a bad shader/programmer error. + TINT_ASSERT(func->Block()) << "root block for function is undefined"; + + if (func->Block()->Is()) { + AddError(func) << "root block for function cannot be a multi-in block"; + return; + } + + Hashset param_set{}; + for (auto* param : func->Params()) { + if (!param->Alive()) { + AddError(param) << "destroyed parameter found in function parameter list"; + return; + } + + if (!param_set.Add(param)) { + AddError(param) << "function parameter is not unique"; + return; + } + + if (!param->Type()) { + AddError(param) << "function parameter has nullptr type"; + return; + } + + if (!param->Function()) { + AddError(param) << "function parameter has nullptr parent function"; + return; + } + + if (param->Function() != func) { + AddError(param) << "function parameter has incorrect parent function"; + AddNote(param->Function()) << "parent function declared here"; + return; + } + + // TODO(516717234): Move to functional + CheckType(param->Type(), [&]() -> diag::Diagnostic& { return AddError(param); }); + + // TODO(516717234): Move to functional + if (func->IsFragment()) { + WalkTypeAndMembers(param, param->Type(), param->Attributes(), + [this](const auto* p, const auto* t, const auto& a) { + CheckFrontFacingIfBool( + p, a, t, + "fragment entry point params can only be a bool if " + "decorated with @builtin(front_facing)"); + }); + } else if (func->IsEntryPoint()) { + WalkTypeAndMembers( + param, param->Type(), param->Attributes(), + [this](const auto* p, const auto* t, const auto&) { + CheckNotBool(p, t, + "entry point params can only be a bool for fragment shaders"); + }); + } + + // TODO(516717234): Move to functional + if (func->IsEntryPoint()) { + ValidateShaderIOAnnotations(param, param->Type(), param->BindingPoint(), + param->Attributes(), ShaderIOKind::kInputParam); + } else { + if (param->BindingPoint().has_value()) { + AddError(param) + << "input param to non-entry point function has a binding point set"; + } + + if (param->Builtin().has_value()) { + AddError(param) << "builtins can only be decorated on entry point params"; + } + } + + scope_stack_.Add(param); + } + + // TODO(516717234): Move to functional + CheckType(func->ReturnType(), [&]() -> diag::Diagnostic& { return AddError(func); }); + + // TODO(516717234): Determine what below to move to function. + + ValidateIOAttributes(func); + CheckWorkgroupSize(func); + CheckSubgroupSize(func); + + if (func->IsEntryPoint()) { + ValidateShaderIOAnnotations(func, func->ReturnType(), std::nullopt, + func->ReturnAttributes(), ShaderIOKind::kResultValue); + + WalkTypeAndMembers( + func, func->ReturnType(), func->ReturnAttributes(), + [this](const Function* f, const core::type::Type* t, const IOAttributes&) { + CheckNotBool(f, t, "entry point returns can not be 'bool'"); + }); + + Hashset binding_points{}; + const Var* user_declared_immediate = nullptr; + + for (auto var : referenced_module_vars_.TransitiveReferences(func)) { + if (!ir_.properties.Contains(Property::kAllowDuplicateBindings) && + var->BindingPoint().has_value()) { + auto bp = var->BindingPoint().value(); + if (!binding_points.Add(bp)) { + AddError(var) << "found non-unique binding point, " << bp + << ", being referenced in entry point, " << NameOf(func); + } + } + + const auto* mv = var->Result()->Type()->As(); + const auto* ty = var->Result()->Type()->UnwrapPtrOrRef(); + const auto attr = var->Attributes(); + if (!mv || !ty) { + continue; + } + + auto address_space = mv->AddressSpace(); + switch (address_space) { + case AddressSpace::kImmediate: + if (user_declared_immediate) { + AddError(var) + << "multiple user-declared immediate data variables referenced " + "by entry point " + << NameOf(func); + } + user_declared_immediate = var; + continue; + case AddressSpace::kWorkgroup: + if (!func->IsCompute()) { + AddError(var) << "workgroup variable cannot be used in a " << func->Stage() + << " shader"; + } + continue; + case AddressSpace::kPixelLocal: + if (!func->IsFragment()) { + AddError(var) << "pixel_local variable cannot be used in a " + << func->Stage() << " shader"; + } + continue; + case AddressSpace::kIn: + case AddressSpace::kOut: + break; + default: + continue; + } + + if (func->IsFragment() && address_space == AddressSpace::kIn) { + WalkTypeAndMembers( + var, ty, attr, [this](const auto* v, const auto* t, const auto& a) { + CheckFrontFacingIfBool( + v, a, t, + "input address space values referenced by fragment shaders " + "can only be 'bool' if decorated with " + "@builtin(front_facing)"); + }); + } else { + WalkTypeAndMembers( + var, ty, attr, [this](const auto* v, const auto* t, const auto&) { + CheckNotBool( + v, t, + "IO address space values referenced by shader entry points can " + "only be 'bool' if in the input space, used only by fragment " + "shaders and decorated with @builtin(front_facing)"); + }); + } + } + } + + if (func->IsVertex()) { + CheckPositionPresentForVertexOutput(func); + } + + QueueBlock(func->Block()); + ProcessTasks(); +} + +void Structural::ValidateIOAttributes(const Function* func) { + const auto stage = func->Stage(); + struct Task { + const CastableBase* anchor; + const core::type::Type* type; + const IOAttributes& attr; + IODirection dir; + ShaderIOKind io_kind; + }; + Vector tasks; + + // Gather parameters. + for (auto* param : func->Params()) { + tasks.Push({param, param->Type(), param->Attributes(), IODirection::kInput, + ShaderIOKind::kInputParam}); + } + + // Gather return value. + tasks.Push({func, func->ReturnType(), func->ReturnAttributes(), IODirection::kOutput, + ShaderIOKind::kResultValue}); + + // Gather referenced module variables. + for (auto* var : referenced_module_vars_.TransitiveReferences(func)) { + auto* mv = var->Result()->Type()->As(); + if (mv == nullptr) { + continue; + } + if (mv->AddressSpace() == AddressSpace::kIn || mv->AddressSpace() == AddressSpace::kOut || + mv->AddressSpace() == AddressSpace::kHandle) { + tasks.Push({var, mv->StoreType(), var->Attributes(), + validator::IODirectionFor(mv->AddressSpace()), + ShaderIOKind::kModuleScopeVar}); + } + } + + if (stage != Function::PipelineStage::kUndefined) { + // Shared context for blend_src and location validation + BlendSrcContext input_ctx{func->Stage(), {}, {}, nullptr, IODirection::kInput}; + BlendSrcContext output_ctx{func->Stage(), {}, {}, nullptr, IODirection::kOutput}; + + // First pass: pre-populate location hashes for blend_src. + for (const auto& task : tasks) { + auto& ctx = task.dir == IODirection::kInput ? input_ctx : output_ctx; + WalkTypeAndMembers( + ctx, task.type, task.attr, + [task](BlendSrcContext& c, const core::type::Type*, const IOAttributes& a) { + if (a.blend_src.has_value() && a.location.has_value()) { + c.locations.Add(a.location.value(), task.anchor); + } + }); + } + + // Second pass: validate blend_src usages. + for (const auto& task : tasks) { + auto& ctx = task.dir == IODirection::kInput ? input_ctx : output_ctx; + CheckBlendSrc(ctx, task.anchor, task.type, task.attr); + } + + if (!output_ctx.blend_srcs.IsEmpty()) { + if (output_ctx.blend_srcs.Count() != 2) { + AddError(func) << "if any @blend_src is used on an output, then @blend_src(0) and " + "@blend_src(1) must be used"; + } + } + + // Third pass: validate all non-blend_src location usages. + for (const auto& task : tasks) { + if (task.dir == IODirection::kInput) { + CheckLocation(input_ctx.locations, task.anchor, task.attr, func->Stage(), task.type, + task.dir); + } else if (task.dir == IODirection::kOutput) { + CheckLocation(output_ctx.locations, task.anchor, task.attr, func->Stage(), + task.type, task.dir); + } + } + } + + // Validate all the interpolation usages. + for (const auto& task : tasks) { + CheckInterpolation(task.anchor, task.type, task.attr, stage, task.dir); + } + + if (stage != Function::PipelineStage::kUndefined) { + // Validate all the binding_point usages, and ensure things that require binding_point have + // them. + for (const auto& task : tasks) { + CheckBindingPoint(task.anchor, task.type, task.attr, task.io_kind); + } + } + + IOAttributeContext impl_ctx{.input_builtins = {}, .output_builtins = {}}; + // Validate all remaining attributes on IO objects + for (const auto& task : tasks) { + ValidateIOAttributesImpl(impl_ctx, task.anchor, task.type, task.attr, stage, task.dir, + task.io_kind); + } +} + +void Structural::ValidateIOAttributesImpl(IOAttributeContext& ctx, + const CastableBase* msg_anchor, + const core::type::Type* ty, + const IOAttributes& attr, + Function::PipelineStage stage, + IODirection dir, + ShaderIOKind io_kind) { + bool skip_builtins = capabilities_.Contains(Capability::kLoosenValidationForShaderIO) && + io_kind == ShaderIOKind::kModuleScopeVar; + const IOAttributeUsage usage = IOAttributeUsageFor(stage, dir); + WalkTypeAndMembers( + *this, ty, attr, + [&ctx, msg_anchor, usage, io_kind, skip_builtins, dir]( + Structural& v, const core::type::Type* t, const IOAttributes& a) { + const auto checkers = IOAttributeCheckersFor(a, skip_builtins); + if (checkers.IsEmpty()) { + return; + } + + if (a.builtin.has_value() && !skip_builtins && + usage != IOAttributeUsage::kUndefinedUsage) { + const auto& builtin = a.builtin.value(); + + uint32_t count = 0; + switch (dir) { + case IODirection::kInput: + count = ++(ctx.input_builtins.GetOrAddZeroEntry(builtin).value); + break; + case IODirection::kOutput: + count = ++(ctx.output_builtins.GetOrAddZeroEntry(builtin).value); + break; + default: + // This shouldn't ever happen, but this will get caught later in the + // checker, so just ignoring + break; + } + if (v.ir_.properties.Contains(Property::kAllowClipDistancesOnF32ScalarAndVector) && + builtin == BuiltinValue::kClipDistances) { + if (count > 2) { + v.AddError(msg_anchor) + << "too many instances of builtin 'clip_distances' on entry point " + << ToString(dir) + << ", only two allowed with 'kAllowClipDistancesOnF32ScalarAndVector' " + "property enabled"; + } + } else { + if (count > 1) { + v.AddError(msg_anchor) + << "duplicate instance of builtin '" << ToString(builtin) + << "' on entry point " << ToString(dir) + << ", must be unique per entry point i/o direction"; + } + } + } + + auto failed = tint::Hashset(); + + if (usage != IOAttributeUsage::kUndefinedUsage) { + for (const auto* checker : checkers) { + if (!checker->valid_usages.Contains(usage)) { + failed.Add(checker); + + std::stringstream msg; + msg << ToString(checker->kind) << " IO attributes cannot be declared for a " + << ToString(usage) << ". "; + if (checker->valid_usages.Size() == 1) { + const auto& u = *checker->valid_usages.begin(); + msg << "They can only be used for a " << ToString(u) << "."; + } else { + msg << "They can only be used for " << ToString(checker->valid_usages); + } + v.AddError(msg_anchor) << msg.str(); + } + } + } + + for (const auto& checker : checkers) { + if (failed.Contains(checker)) { + continue; + } + + if (!checker->valid_io_kinds.Contains(io_kind)) { + failed.Add(checker); + + std::stringstream msg; + msg << ToString(checker->kind) << " IO attributes cannot be declared on a " + << ToString(io_kind) << ". "; + if (checker->valid_io_kinds.Size() == 1) { + const auto& k = *checker->valid_io_kinds.begin(); + msg << "They can only be used on a " << ToString(k) << "."; + } else { + msg << "They can only be used on " << ToString(checker->valid_io_kinds); + } + v.AddError(msg_anchor) << msg.str(); + } + } + + for (const auto& checker : checkers) { + if (failed.Contains(checker)) { + continue; + } + + if (!checker->type_check(t, v.ir_.properties)) { + failed.Add(checker); + v.AddError(msg_anchor) << ToString(checker->kind) << " " << checker->type_error; + } + } + + for (const auto& checker : checkers) { + if (failed.Contains(checker)) { + continue; + } + + if (auto res = checker->check(t, a, v.ir_.properties, usage); res != Success) { + failed.Add(checker); + v.AddError(msg_anchor) << res.Failure(); + } + } + }); +} + +void Structural::CheckFrontFacingIfBool(const CastableBase* msg_anchor, + const IOAttributes& attr, + const core::type::Type* ty, + const std::string& err) { + if (ty->Is() && attr.builtin != BuiltinValue::kFrontFacing) { + AddError(msg_anchor) << err; + } +} + +void Structural::CheckNotBool(const CastableBase* msg_anchor, + const core::type::Type* ty, + const std::string& err) { + if (ty->Is()) { + AddError(msg_anchor) << err; + } +} + +void Structural::CheckWorkgroupSize(const Function* func) { + if (!func->IsCompute()) { + if (func->WorkgroupSize().has_value()) { + AddError(func) << "@workgroup_size only valid on compute entry point"; + } + return; + } + + if (!func->WorkgroupSize().has_value()) { + AddError(func) << "compute entry point requires @workgroup_size"; + return; + } + + auto workgroup_sizes = func->WorkgroupSize().value(); + // The number parameters cannot be checked here, since it is stored internally as a 3 element + // array, so will always have 3 elements at this point. + TINT_ASSERT(workgroup_sizes.size() == 3); + + uint64_t total_size = 1; + + std::optional sizes_ty; + for (auto* size : workgroup_sizes) { + if (!size || !size->Type()) { + AddError(func) << "a @workgroup_size param is undefined or missing a type"; + return; + } + + auto* ty = size->Type(); + if (!ty->IsAnyOf()) { + AddError(func) << "@workgroup_size params must be an 'i32' or 'u32', received " + << NameOf(ty); + return; + } + + if (!sizes_ty.has_value()) { + sizes_ty = ty; + } + + if (sizes_ty != ty) { + AddError(func) << "@workgroup_size params must be all 'i32's or all 'u32's"; + return; + } + + if (auto* c = size->As()) { + if (c->Value()->ValueAs() <= 0) { + AddError(func) << "@workgroup_size params must be greater than 0"; + return; + } + total_size *= c->Value()->ValueAs(); + + constexpr uint64_t kMaxGridSize = 0xffffffff; + if (total_size > kMaxGridSize) { + AddError(func) << "workgroup grid size cannot exceed 0x" << std::hex + << kMaxGridSize; + } + continue; + } + + if (!ir_.properties.Contains(Property::kAllowOverrides)) { + AddError(func) << "@workgroup_size param is not a constant value, and IR property " + "'AllowOverrides' is not enabled"; + return; + } + + if (auto* r = size->As()) { + if (!r->Instruction()) { + AddError(func) << "instruction for @workgroup_size param is not defined"; + return; + } + + if (r->Instruction()->Block() != ir_.root_block) { + AddError(func) << "@workgroup_size param defined by non-module scope value"; + return; + } + + // Since above, it is already checked if the value is in the root block, it is assumed + // to be pipeline creatable here, i.e. const/override or derived from consts and + // overrides. + // If that is not true, that indicates an issue in CheckRootBlock(). + continue; + } + + AddError(func) << "@workgroup_size must be an InstructionResult or a Constant"; + } +} + +void Structural::CheckSubgroupSize(const Function* func) { + // @subgroup_size is optional + if (!func->SubgroupSize().has_value()) { + return; + } + + if (!func->IsCompute()) { + AddError(func) << "@subgroup_size only valid on compute entry point"; + return; + } + + auto subgroup_size = func->SubgroupSize().value(); + if (subgroup_size == nullptr) { + AddError(func) << "a @subgroup_size param must have a value"; + return; + } + + if (!subgroup_size->Type()) { + AddError(func) << "a @subgroup_size param is missing a type"; + return; + } + + auto* ty = subgroup_size->Type(); + if (!ty->IsAnyOf()) { + AddError(func) << "@subgroup_size param must be an 'i32' or 'u32', received " << NameOf(ty); + return; + } + + if (auto* c = subgroup_size->As()) { + int64_t value = c->Value()->ValueAs(); + if (value <= 0) { + AddError(func) << "@subgroup_size param must be greater than 0"; + return; + } + + if (!IsPowerOfTwo(value)) { + AddError(func) << "@subgroup_size param must be a power of 2"; + return; + } + + return; + } + + if (!ir_.properties.Contains(Property::kAllowOverrides)) { + AddError(func) << "@subgroup_size param is not a constant value, and IR property " + "'AllowOverrides' is not enabled"; + return; + } + + if (auto* r = subgroup_size->As()) { + if (!r->Instruction()) { + AddError(func) << "instruction for @subgroup_size param is not defined"; + return; + } + + if (r->Instruction()->Block() != ir_.root_block) { + AddError(func) << "@subgroup_size param defined by non-module scope value"; + return; + } + + if (r->Instruction()->Is()) { + return; + } + } + + AddError(func) << "@subgroup_size must be an InstructionResult or a Constant"; +} + +void Structural::CheckPositionPresentForVertexOutput(const Function* ep) { + if (IsPositionPresent(ep->ReturnAttributes(), ep->ReturnType())) { + return; + } + + for (const auto& var : referenced_module_vars_.TransitiveReferences(ep)) { + const auto* ty = var->Result()->Type()->UnwrapPtrOrRef(); + if (!ty) { + continue; + } + + const auto attr = var->Attributes(); + if (IsPositionPresent(attr, ty)) { + return; + } + } + AddError(ep) << "position must be declared for vertex entry point output"; +} + +void Structural::ProcessTasks() { + while (!tasks_.IsEmpty()) { + tasks_.Pop()(); + } +} + +void Structural::QueueBlock(const Block* blk) { + tasks_.Push([this] { EndBlock(); }); + tasks_.Push([this, blk] { BeginBlock(blk); }); +} + +void Structural::BeginBlock(const Block* blk) { + scope_stack_.Push(); + block_stack_.Push(blk); + + if (auto* mb = blk->As()) { + for (auto* param : mb->Params()) { + if (!param->Alive()) { + AddError(param) << "destroyed parameter found in block parameter list"; + return; + } + if (!param->Block()) { + AddError(param) << "block parameter has nullptr parent block"; + return; + } else if (param->Block() != mb) { + AddError(param) << "block parameter has incorrect parent block"; + AddNote(param->Block()) << "parent block declared here"; + return; + } + + CheckType(param->Type(), [&]() -> diag::Diagnostic& { return AddError(param); }); + + if (param->Type()->Is()) { + AddError(param) << "block parameter type cannot be void"; + } + if (param->Type()->Is()) { + AddError(param) << "block parameter type cannot be a reference"; + } + + scope_stack_.Add(param); + } + } + + if (!blk->Terminator()) { + AddError(blk) << "block does not end in a terminator instruction"; + } + + // Validate the instructions w.r.t. the parent block + for (auto* inst : *blk) { + if (inst->Block() != blk) { + AddError(inst) << "block instruction does not have same block as parent"; + AddNote(blk) << "in block"; + } + } + + // Enqueue validation of the instructions of the block + if (!blk->IsEmpty()) { + QueueInstructions(blk->Instructions()); + } +} + +void Structural::EndBlock() { + scope_stack_.Pop(); + block_stack_.Pop(); +} + +void Structural::QueueInstructions(const Instruction* inst) { + if (diag_.ContainsErrors()) { + return; + } + + tasks_.Push([this, inst] { + // Tasks are processed LIFO, so push the next instruction to the stack before checking the + // current instruction, which may need to add more blocks to the stack itself. + if (inst->next) { + QueueInstructions(inst->next); + } + CheckInstruction(inst); + }); +} + +void Structural::CheckInstruction(const Instruction* inst) { + visited_instructions_.Add(inst); + if (!inst->Alive()) { + AddError(inst) << "destroyed instruction found in instruction list"; + return; + } + + Capabilities allowed_types{}; + + if (auto* call = inst->As(); + call && call->Func() == core::BuiltinFn::kBitcast) { + allowed_types.Add(Capability::kAllow64BitIntegers); + } + + if (auto* call = inst->As()) { + if (call->Op() == core::BinaryOp::kOr || call->Op() == core::BinaryOp::kShiftLeft) { + allowed_types.Add(Capability::kAllow64BitIntegers); + } + } + + if (auto* call = inst->As()) { + // This will miss u64 being used if it isn't on the first result, but convert having + // multiple results is illegal anyway, so will be rejected later in the validator + if (call->Result(0) && call->Result(0)->Type()->Is()) { + allowed_types.Add(Capability::kAllow64BitIntegers); + } + } + + auto results = inst->Results(); + for (size_t i = 0; i < results.Length(); ++i) { + auto* res = results[i]; + if (!res) { + continue; + } + + CheckType( + res->Type(), [&]() -> diag::Diagnostic& { return AddResultError(inst, i); }, + allowed_types); + } + + auto ops = inst->Operands(); + for (size_t i = 0; i < ops.Length(); ++i) { + auto* op = ops[i]; + if (!op) { + continue; + } + + CheckType( + op->Type(), [&]() -> diag::Diagnostic& { return AddError(inst, i); }, allowed_types); + } + + // Push a task to add the results to the scope. + // This ensures that for control instructions, the results are only added to the scope + // after their nested blocks have been evaluated (since tasks are processed LIFO). + tasks_.Push([this, inst] { + for (auto* result : inst->Results()) { + if (result) { + scope_stack_.Add(result); + } + } + }); + + tint::Switch( + inst, // + [&](const Access* a) { CheckAccess(a); }, // + [&](const Binary* b) { CheckBinary(b); }, // + [&](const Call* c) { CheckCall(c); }, // + [&](const If* if_) { CheckIf(if_); }, // + [&](const Let* let) { CheckLet(let); }, // + [&](const Load* load) { CheckLoad(load); }, // + [&](const LoadVectorElement* l) { CheckLoadVectorElement(l); }, // + [&](const Loop* l) { CheckLoop(l); }, // + [&](const Phony* p) { CheckPhony(p); }, // + [&](const Store* s) { CheckStore(s); }, // + [&](const StoreVectorElement* s) { CheckStoreVectorElement(s); }, // + [&](const Switch* s) { CheckSwitch(s); }, // + [&](const Swizzle* s) { CheckSwizzle(s); }, // + [&](const Terminator* b) { CheckTerminator(b); }, // + [&](const Unary* u) { CheckUnary(u); }, // + [&](const Override* o) { CheckOverride(o); }, // + [&](const Var* var) { CheckVar(var); }, // + TINT_ICE_ON_NO_MATCH); +} + +void Structural::CheckOverride(const Override* o) { + // Intentionally not checking operands, since Override may have a null operand + if (!CheckResults(o, Override::kNumResults)) { + return; + } + + if (o->Block() != ir_.root_block) { + AddError(o) << "override must be declared at module scope"; + } + + if (o->Initializer()) { + CheckOperand(o, ir::Var::kInitializerOperandOffset); + } else if (o->Operands().Length() == 0) { + AddError(o) << "override is malformed, missing initializer operand"; + } +} + +void Structural::CheckVar(const Var* var) { + if (!CheckResultsAndOperands(var, Var::kNumResults, Var::kNumOperands)) { + return; + } + + // TODO(516717234): Remove when ValidateShaderIOAnnotations are moved to function validator + auto* result_type = var->Result()->Type(); + auto* mv = result_type->As(); + if (!mv) { + AddError(var) << "result type " << NameOf(result_type) + << " must be a pointer or a reference"; + return; + } + const core::ir::type::ValueArrayCount* count = nullptr; + if (auto* ary = result_type->UnwrapPtr()->As()) { + count = ary->Count()->As(); + } else if (auto* buf = result_type->UnwrapPtr()->As()) { + count = buf->Count()->As(); + } + + if (count) { + if (!scope_stack_.Contains(count->value)) { + AddError(var) << NameOf(count->value) << " is not in scope"; + } + } + + if (var->Initializer()) { + if (!CheckOperand(var, ir::Var::kInitializerOperandOffset)) { + return; + } + } + + // TODO(516717234): Move to functional validator + CheckBindingPoint(var, var->Result(0)->Type(), var->Attributes(), + ShaderIOKind::kModuleScopeVar); + + auto address_space = mv->AddressSpace(); + if (address_space != AddressSpace::kIn && address_space != AddressSpace::kOut) { + CheckInterpolation(var, mv->StoreType(), var->Attributes(), + Function::PipelineStage::kUndefined, IODirection::kResource); + } + + // TODO(516717234): Move to functional validator + if (var->Block() == ir_.root_block) { + if (mv->AddressSpace() == AddressSpace::kIn || mv->AddressSpace() == AddressSpace::kOut) { + ValidateShaderIOAnnotations(var, var->Result()->Type(), var->BindingPoint(), + var->Attributes(), ShaderIOKind::kModuleScopeVar); + } + } +} + +const ir::Function* Structural::ContainingFunction(const ir::Instruction* inst) { + if (inst->Block() == ir_.root_block) { + return nullptr; + } + + return block_to_function_.GetOrAdd(inst->Block(), [&] { // + return ContainingFunction(inst->Block()->Parent()); + }); +} + +Hashset Structural::ContainingEndPoints(const ir::Function* f) { + if (!f) { + return {}; + } + + Hashset result{}; + Hashset visited{f}; + + auto call_sites = user_func_calls_.GetOr(f, Hashset()).Vector(); + while (!call_sites.IsEmpty()) { + auto call_site = call_sites.Pop(); + auto calling_function = ContainingFunction(call_site); + if (!calling_function) { + continue; + } + + if (visited.Contains(calling_function)) { + continue; + } + visited.Add(calling_function); + + if (calling_function->IsEntryPoint()) { + result.Add(calling_function); + } + + for (auto new_call_sites : user_func_calls_.GetOr(f, Hashset())) { + call_sites.Push(new_call_sites); + } + } + + return result; +} + +void Structural::CheckBlendSrc(BlendSrcContext& ctx, + const CastableBase* target, + const core::type::Type* ty, + const IOAttributes& attr) { + if (attr.blend_src.has_value()) { + if (!capabilities_.Contains(Capability::kLoosenValidationForShaderIO)) { + AddError(target) << "blend_src cannot be used on non-struct-member types"; + } + CheckBlendSrcImpl(ctx, target, ty, attr); + } + + if (auto* s = ty->As()) { + if (s->Members().Any([](auto* m) { return m->Attributes().blend_src.has_value(); })) { + auto location_count = 0u; + for (const auto* mem : s->Members()) { + auto& mem_attr = mem->Attributes(); + if (mem_attr.location.has_value()) { + location_count++; + } + CheckBlendSrcImpl(ctx, target, mem->Type(), mem_attr); + } + + if (location_count != 2) { + AddError(target) + << "structs with blend_src members must have exactly 2 members with " + "location annotations"; + } + return; + } + } + + // Reject blend_src on nested members + if (!capabilities_.Contains(Capability::kLoosenValidationForShaderIO)) { + WalkTypeAndMembers( + ctx, ty, attr, + [&target, this](BlendSrcContext&, const core::type::Type*, const IOAttributes& a) { + if (a.blend_src.has_value()) { + AddError(target) + << "blend_src cannot be used on members of non-top level structs"; + } + }); + } +} + +void Structural::CheckBlendSrcImpl(BlendSrcContext& ctx, + const CastableBase* target, + const core::type::Type* ty, + const IOAttributes& attr) { + if (!attr.blend_src.has_value()) { + return; + } + + auto bs_val = attr.blend_src.value(); + if (bs_val != 0 && bs_val != 1) { + AddError(target) << "blend_src value must be 0 or 1"; + } + if (!ctx.blend_srcs.Add(bs_val)) { + AddError(target) << "duplicate blend_src(" << bs_val << ") on entry point " + << ToString(ctx.dir); + } + + if (ctx.dir != IODirection::kOutput || ctx.stage != Function::PipelineStage::kFragment) { + AddError(target) << "blend_src can only be used on fragment shader outputs"; + return; + } + if (!attr.location.has_value() || attr.location.value() != 0) { + AddError(target) << "struct members with blend_src must be located at 0"; + } + + if (!ctx.blend_src_type) { + if (!ty->IsNumericScalarOrVector()) { + AddError(target) << "blend_src must be a numeric scalar or vector, but has type " + << ty->FriendlyName(); + } + ctx.blend_src_type = ty; + } else if (ctx.blend_src_type != ty) { + AddError(target) << "blend_src type " << ty->FriendlyName() + << " does not match other blend_src type " + << ctx.blend_src_type->FriendlyName(); + } +} + +void Structural::CheckLocation(Hashmap& locations, + const CastableBase* target, + const IOAttributes& attr, + const Function::PipelineStage stage, + const core::type::Type* type, + const IODirection dir) { + struct WalkContext { + Structural* validator; + Hashmap& locations; + const CastableBase* target; + const Function::PipelineStage stage; + const IODirection dir; + }; + WalkContext ctx{this, locations, target, stage, dir}; + + WalkTypeAndMembers( + ctx, type, attr, + [](WalkContext& context, const core::type::Type* ty, const IOAttributes& attribute) { + if (ty->Is()) { + return; + } + + if (attribute.blend_src) { + // locations associated with a blend_src usage should already be + // pre-populated in locations + return; + } + + if (attribute.location.has_value()) { + if (context.stage == Function::PipelineStage::kCompute && + context.dir == IODirection::kInput) { + context.validator->AddError(context.target) + << "location attribute is not valid for compute shader inputs"; + } + + auto loc = attribute.location.value(); + if (const auto conflict = context.locations.Get(loc)) { + context.validator->AddError(context.target) + << "duplicate location(" << loc << ") on entry point " + << ToString(context.dir); + context.validator->AddDeclarationNote(*conflict.value); + } else { + context.locations.Add(loc, context.target); + } + } + }); +} + +void Structural::CheckInterpolation(const CastableBase* anchor, + const core::type::Type* ty, + const IOAttributes& attr, + const Function::PipelineStage stage, + const IODirection dir) { + if (!ty) { + return; + } + + bool ctx = false; + + WalkTypeAndMembers( + ctx, ty, attr, + [this, anchor, stage, dir](bool& in_location_composite, const core::type::Type* t, + const IOAttributes& a) { + bool has_location = a.location.has_value() || in_location_composite; + if (!has_location) { + if (auto* str = t->As()) { + has_location |= str->Members().All( + [](const auto* mem) { return mem->Attributes().location.has_value(); }); + } + } + + if (a.interpolation.has_value()) { + has_location |= (capabilities_.Contains(Capability::kLoosenValidationForShaderIO) && + a.builtin.has_value()); + + if (!ir_.properties.Contains(Property::kAllowLocationForNumericComposites) && + t->As()) { + AddError(anchor) << "interpolation cannot be applied to a struct without " + "'kAllowLocationForNumericComposites' property"; + } + + if (t->IsIntegerScalarOrVector()) { + if (a.interpolation.value().type != InterpolationType::kFlat) { + AddError(anchor) + << "interpolation attribute type must be flat for integral types"; + } + } + + auto interp_type = a.interpolation.value().type; + auto interp_sampling = a.interpolation.value().sampling; + if (interp_sampling != InterpolationSampling::kUndefined) { + switch (interp_type) { + case InterpolationType::kFlat: + if (interp_sampling != InterpolationSampling::kFirst && + interp_sampling != InterpolationSampling::kEither) { + AddError(anchor) << "flat interpolation can only use 'first', " + "'either' or undefined sampling parameters"; + } + break; + case InterpolationType::kLinear: + case InterpolationType::kPerspective: + if (interp_sampling != InterpolationSampling::kCenter && + interp_sampling != InterpolationSampling::kCentroid && + interp_sampling != InterpolationSampling::kSample) { + AddError(anchor) << "linear and perspective interpolation can only " + "use 'center', 'centroid', 'sample', or " + "undefined sampling parameters"; + } + break; + case InterpolationType::kUndefined: + AddError(anchor) << "undefined interpolation should on have an " + "undefined sampling parameter"; + break; + default: + TINT_UNREACHABLE(); + } + } + + if (!has_location) { + if (!capabilities_.Contains(Capability::kLoosenValidationForShaderIO)) { + AddError(anchor) << "interpolation attribute requires a location attribute"; + } else { + AddError(anchor) << "interpolation attribute requires a location attribute " + "(or location-like shader I/O annotation)"; + } + } + } else if (has_location && t->IsIntegerScalarOrVector()) { + // Integral vertex outputs and fragment inputs require flat interpolation. + const bool needs_flat = + (stage == Function::PipelineStage::kVertex && dir == IODirection::kOutput) || + (stage == Function::PipelineStage::kFragment && dir == IODirection::kInput); + if (needs_flat) { + AddError(anchor) << "integral user-defined inputs and outputs must have an " + "@interpolate(flat) attribute"; + } + } + + if (t->IsAnyOf()) { + in_location_composite |= a.location.has_value(); + } + }); +} + +void Structural::CheckBindingPoint(const CastableBase* anchor, + const core::type::Type* ty, + const IOAttributes& attr, + const ShaderIOKind& io_kind) { + const auto& binding_point = attr.binding_point; + auto address_space = AddressSpace::kUndefined; + if (const auto* mv = ty->As()) { + address_space = mv->AddressSpace(); + } else { + // ModuleScopeVars transform in MSL backends unwraps pointers to handles + if (ty->IsHandle()) { + address_space = AddressSpace::kHandle; + } + } + + if (binding_point.has_value() && io_kind != ShaderIOKind::kModuleScopeVar && + !ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + AddError(anchor) << "binding_points are only valid on resource variables"; + } + + switch (address_space) { + case AddressSpace::kHandle: + if (!binding_point.has_value()) { + AddError(anchor) << "a " << ToString(address_space) + << " resource requires a binding point"; + } + break; + case AddressSpace::kStorage: + case AddressSpace::kUniform: + if (!binding_point.has_value()) { + AddError(anchor) << "a " << ToString(address_space) + << " resource requires a binding point"; + } + break; + default: + if (binding_point.has_value()) { + AddError(anchor) << "a " << ToString(address_space) + << " non-resource cannot have a binding point"; + } + break; + } +} + +void Structural::ValidateShaderIOAnnotations(const CastableBase* msg_anchor, + const core::type::Type* ty, + const std::optional& binding_point, + const IOAttributes& attr, + ShaderIOKind kind) { + EnumSet annotations; + + // Since there is no entries in the set at this point, this should never fail. + TINT_ASSERT(AddIOAnnotationsFromIOAttributes(annotations, attr) == Success); + + if (binding_point.has_value()) { + annotations.Add(IOAnnotation::kBindingPoint); + } + + if (auto* mv = ty->As()) { + if (mv->AddressSpace() == AddressSpace::kWorkgroup) { + annotations.Add(IOAnnotation::kWorkgroup); + } + } + + if (ty->Is()) { + if (!annotations.Empty()) { + AddError(msg_anchor) << ToString(kind) << " with void type should never be annotated"; + } + return; // Early return because later rules assume non-void types. + } + + if (attr.location.has_value()) { + if (ir_.properties.Contains(Property::kAllowLocationForNumericComposites)) { + std::function is_numeric = + [&is_numeric](const core::type::Type* t) -> bool { + t = t->UnwrapPtrOrRef(); + bool result = false; + tint::Switch( + t, + [&](const core::type::Struct* s) { + for (auto* m : s->Members()) { + if (!is_numeric(m->Type())) { + return; + } + } + result = true; + }, + [&](Default) { + auto* e = t->DeepestElement()->UnwrapPtrOrRef(); + tint::Switch( + e, // + [&](const core::type::Struct* s) { result = is_numeric(s); }, + [&](Default) { result = e->IsNumericScalarOrVector(); }); + }); + return result; + }; + if (!is_numeric(ty)) { + AddError(msg_anchor) + << ToString(kind) + << " with a location attribute must contain only numeric elements " + << ty->FriendlyName(); + return; + } + } else { + if (!ty->UnwrapPtrOrRef()->IsNumericScalarOrVector()) { + AddError(msg_anchor) << ToString(kind) + << " with a location attribute must be a numeric scalar or " + "vector, but has type " + << ty->FriendlyName(); + return; + } + } + } + + if (auto* ty_struct = ty->UnwrapPtrOrRef()->As()) { + for (const auto* mem : ty_struct->Members()) { + EnumSet mem_annotations = annotations; + auto add_result = AddIOAnnotationsFromIOAttributes(mem_annotations, mem->Attributes()); + if (add_result != Success) { + AddError(msg_anchor) + << ToString(kind) + << " struct member has same IO annotation, as top-level struct, '" + << ToString(add_result.Failure()) << "'"; + return; + } + + if (!CheckStructMemberAttributes(mem, [&]() -> diag::Diagnostic& { + return AddError(msg_anchor) << ToString(kind) << " "; + })) { + return; + } + + if (ir_.properties.Contains(Property::kAllowMslEntryPointInterface)) { + if (auto* mv = mem->Type()->As()) { + if (mv->AddressSpace() == AddressSpace::kWorkgroup) { + mem_annotations.Add(IOAnnotation::kWorkgroup); + } + } + } + + if (mem_annotations.Empty()) { + AddError(msg_anchor) << ToString(kind) + << " struct members must have at least one IO annotation, " + "e.g. a binding point, a location, etc"; + } else if (mem_annotations.Size() > 1) { + AddError(msg_anchor) + << ToString(kind) << " struct member has more than one IO annotation, " + << ToString(mem_annotations); + } + } + } else { + if (annotations.Empty()) { + if (!(ir_.properties.Contains(Property::kAllowUnannotatedModuleIOVariables) && + kind == ShaderIOKind::kModuleScopeVar)) { + AddError(msg_anchor) << ToString(kind) + << " must have at least one IO annotation, e.g. a binding " + "point, a location, etc"; + } + } else if (annotations.Size() > 1) { + AddError(msg_anchor) << ToString(kind) << " has more than one IO annotation, " + << ToString(annotations); + } + } +} + +bool Structural::CheckStructMemberAttributes(const core::type::StructMember* member, + std::function make_diag) { + const auto checkers = IOAttributeCheckersFor(member->Attributes(), /*skip_builtins*/ false); + for (const auto* checker : checkers) { + auto res = checker->check(member->Type(), member->Attributes(), ir_.properties, + IOAttributeUsage::kUndefinedUsage); + if (res != Success) { + make_diag() << res.Failure(); + return false; + } + if (!checker->type_check(member->Type(), ir_.properties)) { + make_diag() << ToString(checker->kind) << " " << checker->type_error; + return false; + } + } + + if (member->Attributes().location.has_value()) { + if (ir_.properties.Contains(Property::kAllowLocationForNumericComposites)) { + if (!member->Type()->UnwrapPtrOrRef()->IsNumericScalarOrVector() && + !member->Type()->UnwrapPtrOrRef()->Is()) { + make_diag() << "struct member with a location attribute must be a numeric scalar, " + "a numeric vector or a struct, but has type " + << member->Type()->FriendlyName(); + return false; + } + } else { + if (!member->Type()->UnwrapPtrOrRef()->IsNumericScalarOrVector()) { + make_diag() << "struct member with a location attribute must be " + "a numeric scalar or vector, but has type " + << member->Type()->FriendlyName(); + return false; + } + } + } + return true; +} +void Structural::CheckLet(const Let* l) { + CheckResultsAndOperands(l, Let::kNumResults, Let::kNumOperands); +} + +void Structural::CheckCall(const Call* call) { + tint::Switch( + call, // + [&](const BuiltinCall* c) { CheckBuiltinCall(c); }, // + [&](const MemberBuiltinCall* c) { CheckMemberBuiltinCall(c); }, // + [&](const Construct* c) { CheckConstruct(c); }, // + [&](const Convert* c) { CheckConvert(c); }, // + [&](const Discard* d) { // + stage_restricted_instructions_.Add( + d, SupportedStages{Function::PipelineStage::kFragment}); // + CheckDiscard(d); // + }, // + [&](const UserCall* c) { // + if (c->Target()) { // + auto calls = // + user_func_calls_.GetOr(c->Target(), // + Hashset{}); // + calls.Add(c); // + user_func_calls_.Replace(c->Target(), calls); // + } + CheckUserCall(c); + }, + [&](Default) { + // Validation of custom IR instructions + }); +} + +void Structural::CheckBuiltinCall(const BuiltinCall* call) { + // This check cannot be more precise, since until intrinsic lookup below, it is unknown what + // number of operands are expected, but still need to enforce things are in scope, + // have types, etc. + if (!CheckResults(call, BuiltinCall::kNumResults) || !CheckOperands(call)) { + return; + } + + auto args = Transform<8>(call->Args(), [&](const ir::Value* v) { return v->Type(); }); + + intrinsic::Context context{call->TableData(), type_mgr_, symbols_}; + auto builtin = core::intrinsic::LookupFn(context, call->FriendlyName().c_str(), call->FuncId(), + call->ExplicitTemplateParams(), args, + core::EvaluationStage::kRuntime); + if (builtin != Success) { + AddError(call) << builtin.Failure(); + return; + } + + // Track the stages that this builtin call is limited to, so that we can check them against the + // entry points that they are used from. + SupportedStages stages; + if (builtin->info->flags.Contains(intrinsic::OverloadFlag::kSupportsComputePipeline)) { + stages.Add(Function::PipelineStage::kCompute); + } + if (builtin->info->flags.Contains(intrinsic::OverloadFlag::kSupportsFragmentPipeline)) { + stages.Add(Function::PipelineStage::kFragment); + } + if (builtin->info->flags.Contains(intrinsic::OverloadFlag::kSupportsVertexPipeline)) { + stages.Add(Function::PipelineStage::kVertex); + } + stage_restricted_instructions_.Add(call, stages); + + const core::ir::CoreBuiltinCall* bc = call->As(); + if (bc == nullptr) { + return; + } + CheckCoreBuiltinCall(bc); +} + +void Structural::CheckCoreBuiltinCall(const CoreBuiltinCall* call) { + if (ir_.properties.Contains(Property::kDisallowVectorMinMaxClamp)) { + switch (call->Func()) { + case core::BuiltinFn::kClamp: + case core::BuiltinFn::kMax: + case core::BuiltinFn::kMin: + if (call->Result()->Type()->Is()) { + AddError(call) << "vector " << call->FriendlyName() + << " disallowed by the DisallowVectorMinMaxClamp property"; + } + break; + default: + break; + } + } +} + +void Structural::CheckMemberBuiltinCall(const MemberBuiltinCall* call) { + // This check cannot be more precise, since until intrinsic lookup below, it is unknown what + // number of operands are expected, but still need to enforce things are in scope, + // have types, etc. + CheckResults(call, MemberBuiltinCall::kNumResults) || !CheckOperands(call); +} + +void Structural::CheckConstruct(const Construct* construct) { + CheckResultsAndOperandRange(construct, Construct::kNumResults, Construct::kMinOperands); +} + +void Structural::CheckConvert(const Convert* convert) { + CheckResultsAndOperands(convert, Convert::kNumResults, Convert::kNumOperands); +} + +void Structural::CheckDiscard(const tint::core::ir::Discard* discard) { + CheckResultsAndOperands(discard, Discard::kNumResults, Discard::kNumOperands); +} + +void Structural::CheckUserCall(const UserCall* call) { + CheckResultsAndOperandRange(call, UserCall::kNumResults, UserCall::kMinOperands); + + if (!call->Target()) { + AddError(call, UserCall::kFunctionOperandOffset) << "target not defined or not a function"; + return; + } +} + +void Structural::CheckAccess(const Access* a) { + CheckResultsAndOperandRange(a, Access::kNumResults, Access::kMinNumOperands); +} + +void Structural::CheckBinary(const Binary* b) { + if (!CheckResultsAndOperands(b, Binary::kNumResults, Binary::kNumOperands)) { + return; + } + if (b->Op() == core::BinaryOp::kLogicalAnd) { + AddError(b) << "logical-and is not valid in the IR"; + return; + } + if (b->Op() == core::BinaryOp::kLogicalOr) { + AddError(b) << "logical-or is not valid in the IR"; + return; + } +} + +void Structural::CheckUnary(const Unary* u) { + CheckResultsAndOperands(u, Unary::kNumResults, Unary::kNumOperands); +} + +void Structural::CheckIf(const If* if_) { + CheckResults(if_); + CheckOperands(if_, If::kNumOperands); + + if (if_->False() && if_->False()->Is()) { + AddError(if_) << "if false block must be a block"; + } + if (if_->True() && if_->True()->Is()) { + AddError(if_) << "if true block must be a block"; + } + + tasks_.Push([this] { control_stack_.Pop(); }); + + if (!if_->False()->IsEmpty()) { + QueueBlock(if_->False()); + } + + QueueBlock(if_->True()); + + tasks_.Push([this, if_] { control_stack_.Push(if_); }); +} + +void Structural::CheckLoop(const Loop* l) { + CheckResults(l); + CheckOperands(l, 0); + + if (l->Initializer()->Is()) { + AddError(l->Initializer()) << "loop initializer must be a block"; + } + + if (!l->Initializer()->IsEmpty()) { + if (!l->Initializer()->Terminator() || + !l->Initializer()->Terminator()->Is()) { + AddError(l->Initializer()) << "loop initializer must have a NextIteration terminator"; + } + } + + // Note: Tasks are queued in reverse order of their execution + tasks_.Push([this] { control_stack_.Pop(); }); + if (!l->Initializer()->IsEmpty()) { + tasks_.Push([this] { EndBlock(); }); + } + tasks_.Push([this] { EndBlock(); }); + if (!l->Continuing()->IsEmpty()) { + tasks_.Push([this, l] { + if (!l->Continuing()->Terminator()->IsAnyOf()) { + AddError(l->Continuing()) + << "loop continuing terminator can only be next_iteration or break_if"; + } + EndBlock(); + }); + } + + // ⎡Initializer ⎤ + // ⎢ ⎡Body ⎤⎥ + // ⎣ ⎣ [Continuing ] ⎦⎦ + + if (!l->Continuing()->IsEmpty()) { + tasks_.Push([this, l] { BeginBlock(l->Continuing()); }); + } else if (!l->Continuing()->Params().IsEmpty()) { + AddError(l) << "loop continuing block has parameters but is empty"; + } + + tasks_.Push([this, l] { + CheckLoopBody(l); + BeginBlock(l->Body()); + }); + if (!l->Initializer()->IsEmpty()) { + tasks_.Push([this, l] { BeginBlock(l->Initializer()); }); + } + tasks_.Push([this, l] { control_stack_.Push(l); }); +} + +void Structural::CheckLoopBody(const Loop* loop) { + // If the body block has parameters, there must be an initializer block. + if (!loop->Body()->Params().IsEmpty()) { + if (!loop->HasInitializer()) { + AddError(loop) << "loop with body block parameters must have an initializer"; + } + } +} + +void Structural::CheckSwitch(const Switch* s) { + CheckResults(s); + CheckOperands(s, Switch::kNumOperands); + + tasks_.Push([this] { control_stack_.Pop(); }); + + for (auto& cse : s->Cases()) { + if (cse.selectors.IsEmpty()) { + AddError(s) << "case does not have any selectors"; + } + if (cse.block->Is()) { + AddError(s) << "case block must be a block"; + } + QueueBlock(cse.block); + } + + tasks_.Push([this, s] { control_stack_.Push(s); }); +} + +void Structural::CheckSwizzle(const Swizzle* s) { + CheckResultsAndOperands(s, Swizzle::kNumResults, Swizzle::kNumOperands); +} + +void Structural::CheckTerminator(const Terminator* b) { + // All terminators should have zero results + if (!CheckResults(b, 0)) { + return; + } + + // Operands must be alive and in scope if they are not nullptr. + if (!CheckOperands(b)) { + return; + } + + tint::Switch( + b, // + [&](const ir::BreakIf* i) { CheckBreakIf(i); }, // + [&](const ir::Continue* c) { CheckContinue(c); }, // + [&](const ir::Exit* e) { CheckExit(e); }, // + [&](const ir::NextIteration* n) { CheckNextIteration(n); }, // + [&](const ir::Return* ret) { CheckReturn(ret); }, // + [&](const ir::TerminateInvocation*) {}, // + [&](const ir::Unreachable* u) { CheckUnreachable(u); }, // + TINT_ICE_ON_NO_MATCH); + + if (b->next) { + AddError(b) << "must be the last instruction in the block"; + } +} + +void Structural::CheckBreakIf(const BreakIf* b) { + auto* loop = b->Loop(); + if (loop == nullptr) { + AddError(b) << "has no associated loop"; + return; + } + if (b->Condition() == nullptr) { + AddError(b) << "break_if condition cannot be nullptr"; + return; + } + + auto next_iter_values = b->NextIterValues(); + if (auto* body = loop->Body()) { + CheckOperandsMatchTarget(b, b->ArgsOperandOffset(), next_iter_values.size(), body, + body->Params()); + } + + auto exit_values = b->ExitValues(); + CheckOperandsMatchTarget(b, b->ArgsOperandOffset() + next_iter_values.size(), + exit_values.size(), loop, loop->Results()); +} + +void Structural::CheckContinue(const Continue* c) { + auto* loop = c->Loop(); + if (loop == nullptr) { + AddError(c) << "has no associated loop"; + return; + } + if (!TransitivelyHolds(loop->Body(), c)) { + if (control_stack_.Any(Eq(loop))) { + AddError(c) << "must only be called from loop body"; + } else { + AddError(c) << "called outside of associated loop"; + } + } + + if (auto* cont = loop->Continuing()) { + CheckOperandsMatchTarget(c, Continue::kArgsOperandOffset, c->Args().size(), cont, + cont->Params()); + } +} + +void Structural::CheckExit(const Exit* e) { + if (control_stack_.IsEmpty()) { + AddError(e) << "found outside all control instructions"; + return; + } + if (e->ControlInstruction() == nullptr) { + AddError(e) << "has no parent control instruction"; + return; + } + + auto args = e->Args(); + CheckOperandsMatchTarget(e, e->ArgsOperandOffset(), args.size(), e->ControlInstruction(), + e->ControlInstruction()->Results()); + + tint::Switch( + e, // + [&](const ir::ExitIf* i) { CheckExitIf(i); }, // + [&](const ir::ExitLoop* l) { CheckExitLoop(l); }, // + [&](const ir::ExitSwitch* s) { CheckExitSwitch(s); }, // + TINT_ICE_ON_NO_MATCH); +} + +void Structural::CheckNextIteration(const NextIteration* n) { + auto* loop = n->Loop(); + if (loop == nullptr) { + AddError(n) << "has no associated loop"; + return; + } + + if (loop->Initializer() != n->Block() && loop->Continuing() != n->Block()) { + if (control_stack_.Any(Eq(loop))) { + AddError(n) << "must only be called directly from loop initializer or continuing"; + } else { + AddError(n) << "called outside of associated loop"; + } + } + + if (auto* body = loop->Body()) { + CheckOperandsMatchTarget(n, NextIteration::kArgsOperandOffset, n->Args().size(), body, + body->Params()); + } +} + +void Structural::CheckExitIf(const ExitIf* e) { + if (control_stack_.Back() != e->If()) { + AddError(e) << "if target jumps over other control instructions"; + AddNote(control_stack_.Back()) << "first control instruction jumped"; + } +} + +void Structural::CheckReturn(const Return* ret) { + if (!CheckOperands(ret, Return::kMinOperands, Return::kMaxOperands)) { + return; + } + + auto* func = ret->Func(); + if (func == nullptr) { + // Func() returning nullptr after CheckResultsAndOperandRange is due to the first + // operand being not a function + AddError(ret) << "expected function for first operand"; + return; + } + + if (func != ContainingFunction(ret)) { + AddError(ret) << "function operand does not match containing function"; + return; + } +} + +void Structural::CheckUnreachable(const Unreachable* u) { + CheckResultsAndOperands(u, Unreachable::kNumResults, Unreachable::kNumOperands); +} + +void Structural::CheckControlsAllowingIf(const Exit* exit, const Instruction* control) { + bool found = false; + for (auto ctrl : tint::Reverse(control_stack_)) { + if (ctrl == control) { + found = true; + break; + } + // A exit switch can step over if instructions, but no others. + if (!ctrl->Is()) { + AddError(exit) << control->FriendlyName() + << " target jumps over other control instructions"; + AddNote(ctrl) << "first control instruction jumped"; + return; + } + } + if (!found) { + AddError(exit) << control->FriendlyName() << " not found in parent control instructions"; + } +} + +void Structural::CheckExitSwitch(const ExitSwitch* s) { + CheckControlsAllowingIf(s, s->ControlInstruction()); +} + +void Structural::CheckExitLoop(const ExitLoop* l) { + CheckControlsAllowingIf(l, l->ControlInstruction()); +} + +void Structural::CheckLoad(const Load* l) { + CheckResultsAndOperands(l, Load::kNumResults, Load::kNumOperands); +} + +void Structural::CheckStore(const Store* s) { + CheckResultsAndOperands(s, Store::kNumResults, Store::kNumOperands); +} + +void Structural::CheckLoadVectorElement(const LoadVectorElement* l) { + CheckResultsAndOperands(l, LoadVectorElement::kNumResults, LoadVectorElement::kNumOperands); +} + +void Structural::CheckStoreVectorElement(const StoreVectorElement* s) { + CheckResultsAndOperands(s, StoreVectorElement::kNumResults, StoreVectorElement::kNumOperands); +} + +void Structural::CheckPhony(const Phony* p) { + if (!ir_.properties.Contains(Property::kAllowPhonyInstructions)) { + AddError(p) << "missing property 'kAllowPhonyInstructions'"; + return; + } + + if (!CheckResultsAndOperands(p, Phony::kNumResults, Phony::kNumOperands)) { + return; + } +} + +void Structural::CheckOperandsMatchTarget(const Instruction* source_inst, + size_t source_operand_offset, + size_t source_operand_count, + const CastableBase* target, + VectorRef target_values) { + if (source_operand_count != target_values.Length()) { + auto values = [&](size_t n) { return n == 1 ? " value" : " values"; }; + AddError(source_inst) << "provides " << source_operand_count << values(source_operand_count) + << " but " << NameOf(target) << " expects " << target_values.Length() + << values(target_values.Length()); + AddDeclarationNote(target); + } + size_t count = std::min(source_operand_count, target_values.Length()); + for (size_t i = 0; i < count; i++) { + auto* source_value = source_inst->Operand(source_operand_offset + i); + auto* target_value = target_values[i]; + if (!source_value || !target_value) { + continue; // Caller should be checking operands are not null + } + auto* source_type = source_value->Type(); + auto* target_type = target_value->Type(); + if (source_type != target_type) { + AddError(source_inst, source_operand_offset + i) + << "operand with type " << NameOf(source_type) << " does not match " + << NameOf(target) << " target type " << NameOf(target_type); + AddDeclarationNote(target_value); + } + } +} + +} // namespace tint::core::ir::validator diff --git a/3rdparty/dawn/src/tint/lang/core/ir/structural_validator.h b/3rdparty/dawn/src/tint/lang/core/ir/structural_validator.h new file mode 100644 index 000000000..d8a7a1ff1 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/structural_validator.h @@ -0,0 +1,703 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_CORE_IR_STRUCTURAL_VALIDATOR_H_ +#define SRC_TINT_LANG_CORE_IR_STRUCTURAL_VALIDATOR_H_ + +#include +#include +#include + +#include "src/tint/lang/core/ir/access.h" +#include "src/tint/lang/core/ir/binary.h" +#include "src/tint/lang/core/ir/block_param.h" +#include "src/tint/lang/core/ir/break_if.h" +#include "src/tint/lang/core/ir/capabilities.h" +#include "src/tint/lang/core/ir/construct.h" +#include "src/tint/lang/core/ir/continue.h" +#include "src/tint/lang/core/ir/control_instruction.h" +#include "src/tint/lang/core/ir/convert.h" +#include "src/tint/lang/core/ir/core_builtin_call.h" +#include "src/tint/lang/core/ir/disassembler.h" +#include "src/tint/lang/core/ir/discard.h" +#include "src/tint/lang/core/ir/exit_if.h" +#include "src/tint/lang/core/ir/exit_loop.h" +#include "src/tint/lang/core/ir/exit_switch.h" +#include "src/tint/lang/core/ir/function.h" +#include "src/tint/lang/core/ir/function_param.h" +#include "src/tint/lang/core/ir/if.h" +#include "src/tint/lang/core/ir/instruction.h" +#include "src/tint/lang/core/ir/instruction_result.h" +#include "src/tint/lang/core/ir/io_attribute_validator.h" +#include "src/tint/lang/core/ir/let.h" +#include "src/tint/lang/core/ir/load.h" +#include "src/tint/lang/core/ir/load_vector_element.h" +#include "src/tint/lang/core/ir/loop.h" +#include "src/tint/lang/core/ir/member_builtin_call.h" +#include "src/tint/lang/core/ir/module.h" +#include "src/tint/lang/core/ir/next_iteration.h" +#include "src/tint/lang/core/ir/override.h" +#include "src/tint/lang/core/ir/phony.h" +#include "src/tint/lang/core/ir/referenced_module_vars.h" +#include "src/tint/lang/core/ir/return.h" +#include "src/tint/lang/core/ir/store.h" +#include "src/tint/lang/core/ir/store_vector_element.h" +#include "src/tint/lang/core/ir/switch.h" +#include "src/tint/lang/core/ir/swizzle.h" +#include "src/tint/lang/core/ir/type/array_count.h" +#include "src/tint/lang/core/ir/unary.h" +#include "src/tint/lang/core/ir/unreachable.h" +#include "src/tint/lang/core/ir/user_call.h" +#include "src/tint/lang/core/ir/var.h" +#include "src/tint/lang/core/type/type.h" +#include "src/tint/utils/containers/hashset.h" +#include "src/tint/utils/diagnostic/diagnostic.h" +#include "src/tint/utils/rtti/castable.h" +#include "src/tint/utils/text/styled_text.h" + +namespace tint::core::ir::validator { + +/// State for validating blend_src attributes shared across multiple passes within the same entry +/// point. +struct BlendSrcContext { + Function::PipelineStage stage; + Hashmap locations; + Hashset blend_srcs; + const core::type::Type* blend_src_type = nullptr; + IODirection dir; +}; + +using SupportedStages = tint::EnumSet; + +class Structural { + public: + Structural(const Module& ir, diag::List& diagnostics, Capabilities capabilities); + ~Structural(); + + void Validate(); + + Structural(const Structural&) = delete; + Structural(Structural&&) = delete; + Structural& operator=(const Structural&) = delete; + Structural& operator=(Structural&&) = delete; + + private: + /// Runs validation to confirm the structural soundness of the module. + /// Also runs any validation that is not dependent on the entire module being + /// sound and sets up data structures for later checks. + void RunStructuralSoundnessChecks(); + + /// Checks that there is no direct or indirect recursion. + /// Depends on CheckStructuralSoundness() having previously been run. + void CheckForRecursion(); + + /// Checks that there are no orphaned instructions + /// Depends on CheckStructuralSoundness() having previously been run + void CheckForOrphanedInstructions(); + + /// Checks that entry points do not use instructions that are not supported by their stage. + /// Depends on CheckStructuralSoundness() having previously been run + void CheckStageRestrictedInstructions(); + + /// @returns the IR disassembly, performing a disassemble if this is the first call. + ir::Disassembler& Disassemble(); + + /// Adds an error for the @p inst and highlights the instruction in the disassembly + /// @param inst the instruction + /// @returns the diagnostic + diag::Diagnostic& AddError(const Instruction* inst); + + /// Adds an error for the @p inst operand at @p idx and highlights the operand in the + /// disassembly + /// @param inst the instruction + /// @param idx the operand index + /// @returns the diagnostic + diag::Diagnostic& AddError(const Instruction* inst, size_t idx); + + /// Adds an error for the @p inst result at @p idx and highlgihts the result in the disassembly + /// @param inst the instruction + /// @param idx the result index + /// @returns the diagnostic + diag::Diagnostic& AddResultError(const Instruction* inst, size_t idx); + + /// Adds an error for the @p block and highlights the block header in the disassembly + /// @param blk the block + /// @returns the diagnostic + diag::Diagnostic& AddError(const Block* blk); + + /// Adds an error for the @p param and highlights the parameter in the disassembly + /// @param param the parameter + /// @returns the diagnostic + diag::Diagnostic& AddError(const BlockParam* param); + + /// Adds an error for the @p func and highlights the function in the disassembly + /// @param func the function + /// @returns the diagnostic + diag::Diagnostic& AddError(const Function* func); + + /// Adds an error for the @p param and highlights the parameter in the disassembly + /// @param param the parameter + /// @returns the diagnostic + diag::Diagnostic& AddError(const FunctionParam* param); + + /// Adds an error for the castable base @p base and highlights it in the disassembly + /// @param base the declaration to add an error for + /// @returns the diagnostic + diag::Diagnostic& AddError(const CastableBase* base); + + /// Adds an error the @p block and highlights the block header in the disassembly + /// @param src the source lines to highlight + /// @returns the diagnostic + diag::Diagnostic& AddError(Source src); + + /// Adds a note to @p inst and highlights the instruction in the disassembly + /// @param inst the instruction + diag::Diagnostic& AddNote(const Instruction* inst); + + /// Adds a note to @p func and highlights the function in the disassembly + /// @param func the function + diag::Diagnostic& AddNote(const Function* func); + + /// Adds a note to @p inst for operand @p idx and highlights the operand in the disassembly + /// @param inst the instruction + /// @param idx the operand index + diag::Diagnostic& AddOperandNote(const Instruction* inst, size_t idx); + + /// Adds a note to @p inst for result @p idx and highlights the result in the disassembly + /// @param inst the instruction + /// @param idx the result index + diag::Diagnostic& AddResultNote(const Instruction* inst, size_t idx); + + /// Adds a note to @p blk and highlights the block in the disassembly + /// @param blk the block + diag::Diagnostic& AddNote(const Block* blk); + + /// Adds a note to the diagnostics + /// @param src the source lines to highlight + diag::Diagnostic& AddNote(Source src = {}); + + /// Adds a note to the diagnostics highlighting where the value instruction or block is + /// declared, if it has a source location. + /// @param decl the value instruction or block + void AddDeclarationNote(const CastableBase* decl); + + /// Adds a note to the diagnostics highlighting where the block is declared, if it has a source + /// location. + /// @param block the block + void AddDeclarationNote(const Block* block); + + /// Adds a note to the diagnostics highlighting where the block parameter is declared, if it + /// has a source location. + /// @param param the block parameter + void AddDeclarationNote(const BlockParam* param); + + /// Adds a note to the diagnostics highlighting where the function is declared, if it has a + /// source location. + /// @param fn the function + void AddDeclarationNote(const Function* fn); + + /// Adds a note to the diagnostics highlighting where the function parameter is declared, if it + /// has a source location. + /// @param param the function parameter + void AddDeclarationNote(const FunctionParam* param); + + /// Adds a note to the diagnostics highlighting where the instruction is declared, if it has a + /// source location. + /// @param inst the inst + void AddDeclarationNote(const Instruction* inst); + + /// Adds a note to the diagnostics highlighting where instruction result was declared, if it has + /// a source location. + /// @param res the res + void AddDeclarationNote(const InstructionResult* res); + + /// @param decl the type, value, instruction or block to get the name for + /// @returns the styled name for the given value, instruction or block + StyledText NameOf(const CastableBase* decl); + + // @param ty the type to get the name for + /// @returns the styled name for the given type + StyledText NameOf(const core::type::Type* ty); + + /// @param v the value to get the name for + /// @returns the styled name for the given value + StyledText NameOf(const Value* v); + + /// @param inst the instruction to get the name for + /// @returns the styled name for the given instruction + StyledText NameOf(const Instruction* inst); + + /// @param block the block to get the name for + /// @returns the styled name for the given block + StyledText NameOf(const Block* block); + + /// Checks the given result is not null and its type is not null + /// @param inst the instruction + /// @param idx the result index + /// @returns true if the result is not null + bool CheckResult(const Instruction* inst, size_t idx); + + /// Checks the results (and their types) for @p inst are not null. If count is specified then + /// number of results is checked to be exact. + /// @param inst the instruction + /// @param count the number of results to check + /// @returns true if the results count is as expected and none are null + bool CheckResults(const ir::Instruction* inst, std::optional count); + + /// Checks the given operand is not null and its type is not null + /// @param inst the instruction + /// @param idx the operand index + /// @returns true if the operand is not null + bool CheckOperand(const Instruction* inst, size_t idx); + + /// Checks the number of operands provided to @p inst and that none of them are null. Also + /// checks that the types for the operands are not null + /// @param inst the instruction + /// @param min_count the minimum number of operands to expect + /// @param max_count the maximum number of operands to expect, if not set, than only the minimum + /// number is checked. + /// @returns true if the number of operands is in the expected range and none are null + bool CheckOperands(const ir::Instruction* inst, + size_t min_count, + std::optional max_count); + + /// Checks the operands (and their types) for @p inst are not null. If count is specified then + /// number of operands is checked to be exact. + /// @param inst the instruction + /// @param count the number of operands to check + /// @returns true if the operands count is as expected and none are null + bool CheckOperands(const ir::Instruction* inst, std::optional count); + + /// Checks the number of results for @p inst are exactly equal to @p num_results and the number + /// of operands is correctly. Both results and operands are confirmed to be non-null. + /// @param inst the instruction + /// @param num_results expected number of results for the instruction + /// @param min_operands the minimum number of operands to expect + /// @param max_operands the maximum number of operands to expect, if not set, than only the + /// minimum number is checked. + /// @returns true if the result and operand counts are as expected and none are null + bool CheckResultsAndOperandRange(const ir::Instruction* inst, + size_t num_results, + size_t min_operands, + std::optional max_operands); + + /// Checks the number of results and operands for @p inst are exactly equal to num_results + /// and num_operands, respectively, and that none of them are null. + /// @param inst the instruction + /// @param num_results expected number of results for the instruction + /// @param num_operands expected number of operands for the instruction + /// @returns true if the result and operand counts are as expected and none are null + bool CheckResultsAndOperands(const ir::Instruction* inst, + size_t num_results, + size_t num_operands); + + /// Checks that @p type is allowed by the spec, and does not use any types that are prohibited + /// by the target properties. + /// @param type the type + /// @param diag a function that creates an error diagnostic for the source of the type + void CheckType(const core::type::Type* type, + std::function diag, + Capabilities allow_caps = {}); + + /// Validates the root block + /// @param blk the block + void CheckRootBlock(const Block* blk); + + /// Validates the given instruction is only used in the root block. + /// @param inst the instruction + void CheckOnlyUsedInRootBlock(const Instruction* inst); + + /// Validates the given function + /// @param func the function to validate + void CheckFunction(const Function* func); + + /// Validates the workgroup_size attribute for a given function + /// @param func the function to validate + void CheckWorkgroupSize(const Function* func); + + /// Validates the subgroup_size attribute for a given function + /// @param func the function to validate + void CheckSubgroupSize(const Function* func); + + /// Validates the specific function as a vertex entry point + /// @param ep the function to validate + void CheckPositionPresentForVertexOutput(const Function* ep); + + /// Validates the spec rules for IO attribute usage for a function. + /// @param func the function to validate + void ValidateIOAttributes(const Function* func); + + /// Implementation for validating the spec rules for IO attribute usage. + /// @param ctx context object shared between the multiple invocations of this per entry point + /// @param msg_anchor the object to anchor the error message to + /// @param ty the data type being decorated by the attributes + /// @param attr the attributes to test + /// @param stage the shader stage the builtin is being used + /// @param dir is value being used as an input or an output + /// @param io_kind is the type of shader IO object the attribute is attached to + void ValidateIOAttributesImpl(IOAttributeContext& ctx, + const CastableBase* msg_anchor, + const core::type::Type* ty, + const IOAttributes& attr, + Function::PipelineStage stage, + IODirection dir, + ShaderIOKind io_kind); + + /// Validates that a type is a bool only if it is decorated with @builtin(front_facing). + /// @param msg_anchor where to attach errors to + /// @param attr the IO attributes + /// @param ty the type + /// @param err error message to log when check fails + void CheckFrontFacingIfBool(const CastableBase* msg_anchor, + const IOAttributes& attr, + const core::type::Type* ty, + const std::string& err); + + /// Validates that a type is not a bool. + /// @param msg_anchor where to attach errors to + /// @param ty the type + /// @param err error message to log when check fails + void CheckNotBool(const CastableBase* msg_anchor, + const core::type::Type* ty, + const std::string& err); + + /// Validates the given instruction + /// @param inst the instruction to validate + void CheckInstruction(const Instruction* inst); + + /// Validates the given override + /// @param o the override to validate + void CheckOverride(const Override* o); + + /// Validates the given var + /// @param var the var to validate + void CheckVar(const Var* var); + + /// Validates annotations related to shader IO + /// @param msg_anchor where to attach errors to + /// @param ty type of the value under test + /// @param binding_point the binding information associated with the value + /// @param attr IO attributes associated with the values + /// @param kind the kind Shader IO being performed + void ValidateShaderIOAnnotations(const CastableBase* msg_anchor, + const core::type::Type* ty, + const std::optional& binding_point, + const IOAttributes& attr, + ShaderIOKind kind); + + /// Validates the attributes of a struct member. + /// @param member the struct member + /// @param diag a function that creates an error diagnostic + /// @returns true if the attributes are valid + bool CheckStructMemberAttributes(const core::type::StructMember* member, + std::function make_diag); + + /// Validates the blend_src attribute for a given type, responsible for traversal of inner types + /// and checking rules that span across a multiple attribute instances. + /// @param ctx the blend_src context. + /// @param target the object that has the struct ty. + /// @param ty the ty to validate. + /// @param attr the IO attributes for the object. + void CheckBlendSrc(BlendSrcContext& ctx, + const CastableBase* target, + const core::type::Type* ty, + const IOAttributes& attr); + + /// Validates the details of a single attribute instance. + /// @param ctx the blend_src context. + /// @param target the object that has the struct type. + /// @param ty the type to validate. + /// @param attr the IO attributes for the object. + void CheckBlendSrcImpl(BlendSrcContext& ctx, + const CastableBase* target, + const core::type::Type* ty, + const IOAttributes& attr); + + /// Validates location attributes on entry point IO. + /// @param locations the map of locations used so far for the current IO direction. + /// @param target the object that has the location attribute. + /// @param attr the IO attributes for the object. + /// @param stage the pipeline stage of the entry point. + /// @param type the type of the IO object. + /// @param dir the IO direction (input or output). + void CheckLocation(Hashmap& locations, + const CastableBase* target, + const IOAttributes& attr, + Function::PipelineStage stage, + const core::type::Type* type, + IODirection dir); + + /// Validates interpolation attributes on entry point IO. + /// @param anchor where to attach error messages to. + /// @param ty the type of the IO object + /// @param attr the IO attributes of the object. + /// @param stage the shader stage + /// @param dir the direction of the IO usage + void CheckInterpolation(const CastableBase* anchor, + const core::type::Type* ty, + const IOAttributes& attr, + Function::PipelineStage stage, + IODirection dir); + + /// Validates binding_point attributes on entry point IO. + /// @param anchor where to attach error messages to. + /// @param ty the type of the IO object + /// @param attr the IO attributes of the object + /// @param io_kind the type of shader IO object binding point is attached to + void CheckBindingPoint(const CastableBase* anchor, + const core::type::Type* ty, + const IOAttributes& attr, + const ShaderIOKind& io_kind); + + /// Validates the given let + /// @param l the let to validate + void CheckLet(const Let* l); + + /// Validates the given call + /// @param call the call to validate + void CheckCall(const Call* call); + + /// Validates the given builtin call + /// @param call the call to validate + void CheckBuiltinCall(const BuiltinCall* call); + + /// Validates a core builtin call + /// @param call the call to validate + /// @param overload the call intrinsic overload + void CheckCoreBuiltinCall(const CoreBuiltinCall* call); + + /// Validates the given member builtin call + /// @param call the member call to validate + void CheckMemberBuiltinCall(const MemberBuiltinCall* call); + + /// Validates the given construct + /// @param construct the construct to validate + void CheckConstruct(const Construct* construct); + + /// Validates the given convert + /// @param convert the convert to validate + void CheckConvert(const Convert* convert); + + /// Validates the given discard + /// @note Does not validate that the discard is in a fragment shader, that + /// needs to be handled later in the validation. + /// @param discard the discard to validate + void CheckDiscard(const Discard* discard); + + /// Validates the given user call + /// @param call the call to validate + void CheckUserCall(const UserCall* call); + + /// Validates the given access + /// @param a the access to validate + void CheckAccess(const Access* a); + + /// Validates the given binary + /// @param b the binary to validate + void CheckBinary(const Binary* b); + + /// Validates the given unary + /// @param u the unary to validate + void CheckUnary(const Unary* u); + + /// Validates the given if + /// @param if_ the if to validate + void CheckIf(const If* if_); + + /// Validates the given loop + /// @param l the loop to validate + void CheckLoop(const Loop* l); + + /// Validates the loop body block + /// @param l the loop to validate + void CheckLoopBody(const Loop* l); + + /// Validates the given switch + /// @param s the switch to validate + void CheckSwitch(const Switch* s); + + /// Validates the given swizzle + /// @param s the swizzle to validate + void CheckSwizzle(const Swizzle* s); + + /// Validates the given terminator + /// @param b the terminator to validate + void CheckTerminator(const Terminator* b); + + /// Validates the break if instruction + /// @param b the break if to validate + void CheckBreakIf(const BreakIf* b); + + /// Validates the continue instruction + /// @param c the continue to validate + void CheckContinue(const Continue* c); + + /// Validates the given exit + /// @param e the exit to validate + void CheckExit(const Exit* e); + + /// Validates the next iteration instruction + /// @param n the next iteration to validate + void CheckNextIteration(const NextIteration* n); + + /// Validates the given exit if + /// @param e the exit if to validate + void CheckExitIf(const ExitIf* e); + + /// Validates the given return + /// @param r the return to validate + void CheckReturn(const Return* r); + + /// Validates the given unreachable + /// @param u the unreachable to validate + void CheckUnreachable(const Unreachable* u); + + /// Validates the @p exit targets a valid @p control instruction where the instruction may jump + /// over if control instructions. + /// @param exit the exit to validate + /// @param control the control instruction targeted + void CheckControlsAllowingIf(const Exit* exit, const Instruction* control); + + /// Validates the given exit switch + /// @param s the exit switch to validate + void CheckExitSwitch(const ExitSwitch* s); + + /// Validates the given exit loop + /// @param l the exit loop to validate + void CheckExitLoop(const ExitLoop* l); + + /// Validates the given load + /// @param l the load to validate + void CheckLoad(const Load* l); + + /// Validates the given store + /// @param s the store to validate + void CheckStore(const Store* s); + + /// Validates the given load vector element + /// @param l the load vector element to validate + void CheckLoadVectorElement(const LoadVectorElement* l); + + /// Validates the given store vector element + /// @param s the store vector element to validate + void CheckStoreVectorElement(const StoreVectorElement* s); + + /// Validates the given phony assignment + /// @param p the phony assignment to validate + void CheckPhony(const Phony* p); + + /// Validates that the number and types of the source instruction operands match the target's + /// values. + /// @param source_inst the source instruction + /// @param source_operand_offset the index of the first operand of the source instruction + /// @param source_operand_count the number of operands of the source instruction + /// @param target the receiver of the operand values + /// @param target_values the receiver of the operand values + void CheckOperandsMatchTarget(const Instruction* source_inst, + size_t source_operand_offset, + size_t source_operand_count, + const CastableBase* target, + VectorRef target_values); + + /// @param inst the instruction + /// @param idx the operand index + /// @returns the vector pointer type for the given instruction operand + const core::type::Type* GetVectorPtrElementType(const Instruction* inst, size_t idx); + + /// @returns true if @p ty and its elements can be loaded + bool CanLoad(const core::type::Type* ty); + + /// Executes all the pending tasks + void ProcessTasks(); + + /// Queues the block to be validated with ProcessTasks() + /// @param blk the block to validate + void QueueBlock(const Block* blk); + + /// Queues the list of instructions starting with @p inst to be validated + /// @param inst the first instruction + void QueueInstructions(const Instruction* inst); + + /// Begins validation of the block @p blk, and its instructions. + /// BeginBlock() pushes a new scope for values. + /// Must be paired with a call to EndBlock(). + void BeginBlock(const Block* blk); + + /// Ends validation of the block opened with BeginBlock() and closes the block's scope for + /// values. + void EndBlock(); + + /// Get the function that contains an instruction. + /// @param inst the instruction + /// @returns the function + const ir::Function* ContainingFunction(const ir::Instruction* inst); + + /// Get any endpoints that call a function. + /// @param f the function + /// @returns all end points that call the function + Hashset ContainingEndPoints(const ir::Function* f); + + /// ScopeStack holds a stack of values that are currently in scope + struct ScopeStack { + void Push() { stack_.Push({}); } + void Pop() { stack_.Pop(); } + void Add(const Value* value) { stack_.Back().Add(value); } + bool Contains(const Value* value) { + return stack_.Any([&](auto& v) { return v.Contains(value); }); + } + bool IsEmpty() const { return stack_.IsEmpty(); } + + private: + Vector, 4> stack_; + }; + + const Module& ir_; + diag::List& diag_; + Capabilities capabilities_; + std::optional disassembler_; // Use Disassemble() + + SymbolTable symbols_ = SymbolTable::Wrap(ir_.symbols); + core::type::Manager type_mgr_ = core::type::Manager::Wrap(ir_.Types()); + core::ir::ReferencedModuleVars referenced_module_vars_; + + Vector control_stack_; + Vector block_stack_; + ScopeStack scope_stack_; + + Vector, 16> tasks_; + + Hashset all_functions_; + Hashset visited_instructions_; + Hashmap block_to_function_{}; + Hashmap, 4> user_func_calls_; + Hashmap stage_restricted_instructions_; + Hashset validated_types_{}; +}; + +} // namespace tint::core::ir::validator + +#endif // SRC_TINT_LANG_CORE_IR_STRUCTURAL_VALIDATOR_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/terminator.h b/3rdparty/dawn/src/tint/lang/core/ir/terminator.h index 7028ae6fd..3566a619b 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/terminator.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/terminator.h @@ -28,6 +28,8 @@ #ifndef SRC_TINT_LANG_CORE_IR_TERMINATOR_H_ #define SRC_TINT_LANG_CORE_IR_TERMINATOR_H_ +#include + #include "src/tint/lang/core/ir/operand_instruction.h" #include "src/tint/lang/core/ir/value.h" #include "src/tint/utils/rtti/castable.h" @@ -47,11 +49,11 @@ class Terminator : public Castable> { virtual size_t ArgsOperandOffset() const { return 0; } /// @returns the call arguments - tint::Slice Args() { return operands_.Slice().Offset(ArgsOperandOffset()); } + std::span Args() { return operands_.AsSpan().subspan(ArgsOperandOffset()); } /// @returns the call arguments - tint::Slice Args() const { - return operands_.Slice().Offset(ArgsOperandOffset()); + std::span Args() const { + return operands_.AsSpan().subspan(ArgsOperandOffset()); } }; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_uniform.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from.cc similarity index 56% rename from 3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_uniform.cc rename to 3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from.cc index 6272d68f1..172556c00 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_uniform.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from.cc @@ -25,13 +25,14 @@ // 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. -#include "src/tint/lang/core/ir/transform/array_length_from_uniform.h" +#include "src/tint/lang/core/ir/transform/array_length_from.h" #include #include #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/module.h" +#include "src/tint/lang/core/ir/transform/prepare_immediate_data.h" #include "src/tint/lang/core/ir/validator.h" using namespace tint::core::fluent_types; // NOLINT @@ -46,12 +47,20 @@ struct State { /// The IR module. Module& ir; + bool from_uniform = true; + /// The binding point to use for the uniform buffer. BindingPoint ubo_binding; /// The map from binding point to the element index which holds the size of that buffer. const std::unordered_map& bindpoint_to_size_index; + const core::ir::transform::ImmediateDataLayout& immediate_data_layout; + + uint32_t buffer_sizes_offset = 0; + + uint32_t buffer_sizes_array_elements_num = 0; + /// The IR builder. core::ir::Builder b{ir}; @@ -94,25 +103,42 @@ struct State { block_to_function.Add(func->Block(), func); } - // Look for and replace calls to the array length builtin. + // Look for and replace calls to a length builtin. for (auto* inst : ir.Instructions()) { if (auto* call = inst->As()) { - if (call->Func() == BuiltinFn::kArrayLength) { - MaybeReplace(call); + if (call->Func() == BuiltinFn::kArrayLength || + call->Func() == BuiltinFn::kBufferLength) { + MaybeReplace(call, call->Func() == BuiltinFn::kBufferLength); } } } // Create the lengths structure and update all of the places that need to use it. - // We can only do this after we have replaced all of the array length callsites, now that we + // We can only do this after we have replaced all of the length callsites, now that we // know all of the structure members that we need. CreateLengthsStructure(); } - /// Replace a call to an array length builtin, if the variable appears in the bindpoint map. - /// @param call the arrayLength call to replace - void MaybeReplace(CoreBuiltinCall* call) { - if (auto* length = GetComputedLength(call->Args()[0], call)) { + /// Replace a call to a length builtin, if the variable appears in the bindpoint map. + /// @param call the call to replace + /// @param buffer true if call is a bufferLength call (arrayLength otherwise) + void MaybeReplace(CoreBuiltinCall* call, bool buffer) { + if (buffer) { + auto* buffer_ty = call->Args()[0]->Type()->UnwrapPtr()->As(); + if (call->Args().size() > 1) { + // Length was encoded directly, so just use it. + call->Result()->ReplaceAllUsesWith(call->Args()[1]); + call->Destroy(); + return; + } + if (auto const_count = buffer_ty->ConstantCount()) { + // Constant sized buffer, use its size. + call->Result()->ReplaceAllUsesWith(b.Constant(u32(const_count.value()))); + call->Destroy(); + return; + } + } + if (auto* length = GetComputedLength(call->Args()[0], call, buffer)) { call->Result()->ReplaceAllUsesWith(length); call->Destroy(); } @@ -121,14 +147,18 @@ struct State { /// Get the computed length value for a runtime-sized array pointer. /// @param ptr the pointer to the runtime-sized array /// @param insertion_point the insertion point for new instructions + /// @param buffer true if call is a bufferLength call (arrayLength otherwise) /// @returns the computed length, or nullptr if the original builtin should be used - Value* GetComputedLength(Value* ptr, Instruction* insertion_point) { + Value* GetComputedLength(Value* ptr, + Instruction* insertion_point, + bool buffer, + Constant* struct_index = nullptr) { // Trace back from the value until we reach the originating variable. while (true) { if (auto* param = ptr->As()) { // The length of an array pointer passed as a function parameter will be passed as // an additional parameter to the function. - return GetArrayLengthParam(param); + return GetArrayLengthParam(param, buffer, struct_index); } if (auto* result = ptr->As()) { @@ -138,12 +168,107 @@ struct State { } if (auto* access = result->Instruction()->As()) { ptr = access->Object(); + // Structs must be accessed with a constant. + TINT_IR_ASSERT(ir, ptr->Type()->UnwrapPtr()->Is()); + struct_index = access->Indices()[access->Indices().size() - 1]->As(); + TINT_IR_ASSERT(ir, struct_index); continue; } if (auto* let = result->Instruction()->As()) { ptr = let->Value(); continue; } + if (auto* construct = result->Instruction()->As()) { + // In the MSL backend, buffer_view can decompose into bundled parameters. + TINT_IR_ASSERT(ir, construct->Operands()[0]->Type()->Is()); + ptr = construct->Operands()[0]; + continue; + } + if (auto* call = result->Instruction()->As()) { + // Often buffers are decomposed first, but in the HLSL backend some storage + // buffers sizes come from the resource and some come from a uniform buffer. + // This is dependent on whether the binding uses a dynamic offset in the API. + // Therefore, we must handle the buffer case here if necessary. + // + // We know we have come from an array length call. Either the buffer_view call + // produced one directly or it produced a struct containing one as the last + // member. + + // bufferView and bufferArrayView handling + // + // We know we have come from an array length call. Either the buffer_view call + // produced one directly or it produced a struct containing one as the last + // member. + // We want to calculate: + // + // buffer_size - offset + // length = -------------------- + // stride + // + auto res_ty = call->Result()->Type()->UnwrapPtr(); + uint32_t struct_offset = 0; + uint32_t stride = 0; + TINT_IR_ASSERT(ir, !res_ty->HasFixedFootprint()); + if (auto* str_ty = res_ty->As()) { + auto last = str_ty->Members().Back(); + struct_offset = last->Offset(); + stride = last->Type()->As()->ImplicitStride(); + } else { + stride = res_ty->As()->ImplicitStride(); + } + if (call->Func() == BuiltinFn::kBufferView) { + // where: + // * buffer_size is computed from the uniform buffer input (or direct + // encoding) + // * offset is (structure offset + offset arg) + // * stride is the implicit stride of the runtime array + Value* length = nullptr; + auto* buffer_ty = call->Args()[0]->Type()->UnwrapPtr()->As(); + if (call->Args().size() > 2) { + length = call->Args()[2]; + } else if (auto const_count = buffer_ty->ConstantCount()) { + length = b.Constant(u32(const_count.value())); + } else { + // Impossible to have come from a bufferLength call. + // No need to carry the struct index anymore. + length = GetComputedLength(call->Args()[0], call, false, nullptr); + if (!length) { + return nullptr; + } + } + b.InsertBefore(call, [&] { + auto* arg = call->Args()[1]; + auto* total_offset = b.InsertBitcastIfNeeded(ty.u32(), arg); + if (struct_offset != 0) { + total_offset = b.Add(total_offset, u32(struct_offset))->Result(); + } + length = b.Subtract(length, total_offset)->Result(); + length = b.Divide(length, u32(stride))->Result(); + }); + return length; + } else if (call->Func() == BuiltinFn::kBufferArrayView) { + // Here: + // * buffer_size is the size arg from the call + // * offset is the structure offset (offset arg is not included) + // * stride is the implicit stride of the runtime array + Value* length = b.InsertBitcastIfNeeded(ty.u32(), call->Args()[2]); + b.InsertBefore(call, [&] { + if (struct_offset > 0) { + length = b.Subtract(length, u32(struct_offset))->Result(); + } + length = b.Divide(length, u32(stride))->Result(); + }); + return length; + } + } + if (auto* builtin = result->Instruction()->As()) { + // Various builtins return a pointer: + // * msl.pointer_offset + if (builtin->Args()[0]->Type()->Is()) { + ptr = builtin->Args()[0]; + continue; + } + } TINT_IR_UNREACHABLE(ir) << "unhandled source of a storage buffer pointer: " << result->Instruction()->TypeInfo().name; } @@ -154,8 +279,11 @@ struct State { /// Get (or create) the array length parameter that corresponds to an array parameter. /// @param array_param the array parameter + /// @param buffer true if call is a bufferLength call (arrayLength otherwise) /// @returns the array length parameter - FunctionParam* GetArrayLengthParam(FunctionParam* array_param) { + FunctionParam* GetArrayLengthParam(FunctionParam* array_param, + bool buffer, + Constant* struct_index) { return array_param_to_length_param.GetOrAdd(array_param, [&] { // Add a new parameter to receive the array length. auto* length = b.FunctionParam("tint_array_length"); @@ -166,12 +294,25 @@ struct State { if (auto* call = use.instruction->As()) { // Get the length of the array in the calling function and pass that. auto* arg = call->Args()[array_param->Index()]; - auto* len = GetComputedLength(arg, call); + auto* len = GetComputedLength(arg, call, buffer, struct_index); if (!len) { // The originating variable was not in the bindpoint map, so we need to call - // the original arrayLength builtin as the callee is expecting a value. + // the original builtin as the callee is expecting a value. b.InsertBefore(call, [&] { - len = b.Call(BuiltinFn::kArrayLength, arg)->Result(); + if (buffer) { + len = b.Call(BuiltinFn::kBufferLength, arg)->Result(); + } else { + if (struct_index) { + auto* ptr_ty = arg->Type()->As(); + auto* str_ty = ptr_ty->UnwrapPtr()->As(); + auto* array_ty = str_ty->Members().Back()->Type(); + arg = b.Access(ty.ptr(ptr_ty->AddressSpace(), array_ty, + ptr_ty->Access()), + arg, struct_index) + ->Result(); + } + len = b.Call(BuiltinFn::kArrayLength, arg)->Result(); + } }); } call->AppendArg(len); @@ -223,7 +364,15 @@ struct State { /// @returns the length of the array, or nullptr if the original builtin should be used Value* ComputeArrayLength(Var* var, Instruction* insertion_point) { auto binding = var->BindingPoint(); - TINT_IR_ASSERT(ir, binding); + // Array length could be encountered on a workgroup variable via buffer_view. + TINT_IR_ASSERT( + ir, binding || var->Result()->Type()->As()->AddressSpace() == + core::AddressSpace::kWorkgroup); + + if (!binding) { + // Must be a workgroup variable, so preserve the arrayLength() call. + return nullptr; + } auto idx_it = bindpoint_to_size_index.find(*binding); if (idx_it == bindpoint_to_size_index.end()) { @@ -316,26 +465,42 @@ struct State { const uint32_t size_index = bindpoint_to_size_index.at(info.binding_point); const uint32_t array_index = size_index / 4; const uint32_t vec_index = size_index % 4; - auto* vec_ptr = b.Access>(BufferSizes(), u32(array_index)); - auto* total_buffer_size = b.LoadVectorElement(vec_ptr, u32(vec_index))->Result(); + Value* total_buffer_size = nullptr; + if (from_uniform) { + auto* vec_ptr = b.Access>(BufferSizes(), u32(array_index)); + total_buffer_size = b.LoadVectorElement(vec_ptr, u32(vec_index))->Result(); + } else { + auto* buffer_sizes = b.Access( + ty.ptr(immediate, ty.array(ty.vec4u(), buffer_sizes_array_elements_num)), + immediate_data_layout.var, + u32(immediate_data_layout.IndexOf(buffer_sizes_offset))); + auto* vec_ptr = b.Access(ty.ptr(immediate, ty.vec4u()), buffer_sizes->Result(), + u32(array_index)); + total_buffer_size = b.LoadVectorElement(vec_ptr, u32(vec_index))->Result(); + } // Calculate actual array length: // total_buffer_size - array_offset // array_length = -------------------------------- // array_stride auto* array_size = total_buffer_size; - const type::Array* array_type = nullptr; + uint32_t array_stride = 0; if (auto* str = info.store_type->As()) { // The variable is a struct, so subtract the byte offset of the array member. auto* member = str->Members().Back(); - array_type = member->Type()->As(); + auto* array_type = member->Type()->As(); array_size = b.Subtract(total_buffer_size, u32(member->Offset()))->Result(); + array_stride = array_type->ImplicitStride(); + } else if (info.store_type->Is()) { + array_stride = 1; } else { - array_type = info.store_type->As(); + array_stride = info.store_type->As()->ImplicitStride(); } - TINT_IR_ASSERT(ir, array_type); - auto* length = b.Divide(array_size, u32(array_type->ImplicitStride()))->Result(); + auto* length = array_size; + if (array_stride != 1) { + length = b.Divide(array_size, u32(array_stride))->Result(); + } constructor_values.Push(length); } lengths_constructor->SetOperands(std::move(constructor_values)); @@ -352,22 +517,53 @@ struct State { } /// @returns true if the transformed module needs a storage buffer sizes UBO - bool NeedsStorageBufferSizes() { return buffer_sizes_var != nullptr; } + bool NeedsStorageBufferSizes() { + if (from_uniform) { + return buffer_sizes_var != nullptr; + } else { + return !lengths_structure_members.IsEmpty() && lengths_constructor != nullptr; + } + } }; } // namespace -Result ArrayLengthFromUniform( +Result ArrayLengthFromUniform( Module& ir, BindingPoint ubo_binding, const std::unordered_map& bindpoint_to_size_index) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kArrayLengthFromUniformCapabilities, - "core.ArrayLengthFromUniform")); + core::ir::AssertValid(ir, kArrayLengthCapabilities, "before core.ArrayLengthFromUniform"); - State state{ir, ubo_binding, bindpoint_to_size_index}; + State state{.ir = ir, + .from_uniform = true, + .ubo_binding = ubo_binding, + .bindpoint_to_size_index = bindpoint_to_size_index, + .immediate_data_layout = {}}; state.Process(); - ArrayLengthFromUniformResult result; + ArrayLengthResult result; + result.needs_storage_buffer_sizes = state.NeedsStorageBufferSizes(); + return result; +} + +Result ArrayLengthFromImmediates( + Module& ir, + const core::ir::transform::ImmediateDataLayout& immediate_data_layout, + const uint32_t buffer_sizes_offset, + const uint32_t buffer_sizes_array_elements_num, + const std::unordered_map& bindpoint_to_size_index) { + core::ir::AssertValid(ir, kArrayLengthCapabilities, "before core.ArrayLengthFromImmediates"); + + State state{.ir = ir, + .from_uniform = false, + .ubo_binding = {}, + .bindpoint_to_size_index = bindpoint_to_size_index, + .immediate_data_layout = immediate_data_layout, + .buffer_sizes_offset = buffer_sizes_offset, + .buffer_sizes_array_elements_num = buffer_sizes_array_elements_num}; + state.Process(); + + ArrayLengthResult result; result.needs_storage_buffer_sizes = state.NeedsStorageBufferSizes(); return result; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_immediate.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from.h similarity index 71% rename from 3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_immediate.h rename to 3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from.h index eeacc4125..8beaadbfb 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_immediate.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from.h @@ -1,4 +1,4 @@ -// Copyright 2025 The Dawn & Tint Authors +// Copyright 2024 The Dawn & Tint Authors // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -25,8 +25,8 @@ // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -#ifndef SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_IMMEDIATE_H_ -#define SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_IMMEDIATE_H_ +#ifndef SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_H_ +#define SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_H_ #include @@ -43,14 +43,38 @@ namespace tint::core::ir::transform { struct ImmediateDataLayout; /// The capabilities that the transform can support. -const Capabilities kArrayLengthFromImmediateCapabilities{Capability::kAllowDuplicateBindings}; +const Capabilities kArrayLengthCapabilities{ + Capability::kAllow16BitIntegers, +}; /// The result of running the ArrayLengthFromUniform transform. -struct ArrayLengthFromImmediateResult { - /// `true` if the transformed module needs the storage buffer sizes immediate data. +struct ArrayLengthResult { + /// `true` if the transformed module needs the storage buffer sizes UBO. bool needs_storage_buffer_sizes = false; }; +/// ArrayLengthFromUniform is a transform that replaces calls to the arrayLength() builtin by +/// calculating the array length from the total size of the storage buffer, which is received via a +/// uniform buffer. +/// +/// The generated uniform buffer will have the form: +/// ``` +/// @group(0) @binding(30) +/// var buffer_size_ubo : array, 8>; +/// ``` +/// The binding group and number used for this uniform buffer is provided via the transform config. +/// The transform config also defines the mapping from a storage buffer's `BindingPoint` to the +/// element index that will be used to get the size of that buffer. +/// +/// @param module the module to transform +/// @param ubo_binding the binding point to use for the uniform buffer +/// @param bindpoint_to_size_index the map from binding point to an index which holds the size +/// @returns the transform result or failure +Result ArrayLengthFromUniform( + Module& module, + BindingPoint ubo_binding, + const std::unordered_map& bindpoint_to_size_index); + /// ArrayLengthFromImmediates is a transform that replaces calls to the arrayLength() builtin by /// calculating the array length from the total size of the storage buffer, which is received via /// immediate blocks. @@ -77,7 +101,7 @@ struct ArrayLengthFromImmediateResult { /// be set into the immediate block. /// @returns the transform result or failure /// TODO(crbug.com/366291600): Replace ArrayLengthFromUniform. -Result ArrayLengthFromImmediates( +Result ArrayLengthFromImmediates( Module& module, const core::ir::transform::ImmediateDataLayout& immediate_data_layout, const uint32_t buffer_sizes_offset, @@ -86,4 +110,4 @@ Result ArrayLengthFromImmediates( } // namespace tint::core::ir::transform -#endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_IMMEDIATE_H_ +#endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_immediate.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_immediate.cc deleted file mode 100644 index 36f158b5d..000000000 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_immediate.cc +++ /dev/null @@ -1,365 +0,0 @@ -// Copyright 2025 The Dawn & Tint Authors -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// -// 3. Neither the name of the copyright holder nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include "src/tint/lang/core/ir/transform/array_length_from_immediate.h" - -#include -#include - -#include "src/tint/lang/core/ir/builder.h" -#include "src/tint/lang/core/ir/module.h" -#include "src/tint/lang/core/ir/transform/prepare_immediate_data.h" -#include "src/tint/lang/core/ir/validator.h" - -using namespace tint::core::fluent_types; // NOLINT -using namespace tint::core::number_suffixes; // NOLINT - -namespace tint::core::ir::transform { - -namespace { - -/// PIMPL state for the transform. -struct State { - /// The IR module. - Module& ir; - - /// Immediate data layout contains all immediate block info. - const core::ir::transform::ImmediateDataLayout& immediate_data_layout; - - /// The offset in immediate block for buffer sizes array. - uint32_t buffer_sizes_offset = 0; - - /// The total number of vec4s used to store buffer sizes provided in the immediate block. - uint32_t buffer_sizes_array_elements_num = 0; - - /// The map from binding point to the element index which holds the size of that buffer. - const std::unordered_map& bindpoint_to_size_index; - - /// The IR builder. - core::ir::Builder b{ir}; - - /// The type manager. - core::type::Manager& ty{ir.Types()}; - - /// The construct instruction that creates the array lengths structure in the entry point. - Construct* lengths_constructor = nullptr; - - /// A map from an array function parameter to the function parameter that holds its length. - Hashmap array_param_to_length_param{}; - - /// A map from a function to the structure that holds all of the array lengths. - Hashmap function_to_lengths_structure{}; - - /// A list of structure members for the array lengths structure. - Vector lengths_structure_members{}; - - /// A map from a binding point to its index in the array length structure. - Hashmap bindpoint_to_length_member_index{}; - - /// An ordered list of binding points that map to the structure members. - struct BindingPointInfo { - BindingPoint binding_point{}; - const type::Type* store_type = nullptr; - }; - Vector ordered_bindpoints{}; - - /// A map from block to its containing function. - Hashmap block_to_function{}; - - /// Process the module. - void Process() { - // Seed the block-to-function map with the function entry blocks. - // This is used to determine the owning function for any given instruction. - for (auto& func : ir.functions) { - block_to_function.Add(func->Block(), func); - } - - // Look for and replace calls to the array length builtin. - for (auto* inst : ir.Instructions()) { - if (auto* call = inst->As()) { - if (call->Func() == BuiltinFn::kArrayLength) { - MaybeReplace(call); - } - } - } - - // Create the lengths structure and update all of the places that need to use it. - // We can only do this after we have replaced all of the array length callsites, now that we - // know all of the structure members that we need. - CreateLengthsStructure(); - } - - /// Replace a call to an array length builtin, if the variable appears in the bindpoint map. - /// @param call the arrayLength call to replace - void MaybeReplace(CoreBuiltinCall* call) { - if (auto* length = GetComputedLength(call->Args()[0], call)) { - call->Result()->ReplaceAllUsesWith(length); - call->Destroy(); - } - } - - /// Get the computed length value for a runtime-sized array pointer. - /// @param ptr the pointer to the runtime-sized array - /// @param insertion_point the insertion point for new instructions - /// @returns the computed length, or nullptr if the original builtin should be used - Value* GetComputedLength(Value* ptr, Instruction* insertion_point) { - // Trace back from the value until we reach the originating variable. - while (true) { - if (auto* param = ptr->As()) { - // The length of an array pointer passed as a function parameter will be passed as - // an additional parameter to the function. - return GetArrayLengthParam(param); - } - - if (auto* result = ptr->As()) { - if (auto* var = result->Instruction()->As()) { - // We found the originating variable, so compute its array length. - return ComputeArrayLength(var, insertion_point); - } - if (auto* access = result->Instruction()->As()) { - ptr = access->Object(); - continue; - } - if (auto* let = result->Instruction()->As()) { - ptr = let->Value(); - continue; - } - TINT_IR_UNREACHABLE(ir) << "unhandled source of a storage buffer pointer: " - << result->Instruction()->TypeInfo().name; - } - TINT_IR_UNREACHABLE(ir) - << "unhandled source of a storage buffer pointer: " << ptr->TypeInfo().name; - } - } - - /// Get (or create) the array length parameter that corresponds to an array parameter. - /// @param array_param the array parameter - /// @returns the array length parameter - FunctionParam* GetArrayLengthParam(FunctionParam* array_param) { - return array_param_to_length_param.GetOrAdd(array_param, [&] { - // Add a new parameter to receive the array length. - auto* length = b.FunctionParam("tint_array_length"); - array_param->Function()->AppendParam(length); - - // Update callsites of this function to pass the array length to it. - array_param->Function()->ForEachUseUnsorted([&](core::ir::Usage use) { - if (auto* call = use.instruction->As()) { - // Get the length of the array in the calling function and pass that. - auto* arg = call->Args()[array_param->Index()]; - auto* len = GetComputedLength(arg, call); - if (!len) { - // The originating variable was not in the bindpoint map, so we need to call - // the original arrayLength builtin as the callee is expecting a value. - b.InsertBefore(call, [&] { - len = b.Call(BuiltinFn::kArrayLength, arg)->Result(); - }); - } - call->AppendArg(len); - } - }); - - return length; - }); - } - - /// Get (or create) the array lengths structure for a function. - /// @param func the function that needs the structure - /// @returns the array lengths structure - Value* GetArrayLengthsStructure(Function* func) { - return function_to_lengths_structure.GetOrAdd(func, [&]() -> Value* { - if (func->IsEntryPoint()) { - // Create a placeholder construct instruction for the lengths structure that will be - // filled in later when we know all of the structure members. - TINT_IR_ASSERT(ir, lengths_constructor == nullptr); - lengths_constructor = b.ConstructWithResult(ir.CreateValue()); - lengths_constructor->InsertBefore(func->Block()->Front()); - return lengths_constructor->Result(); - } - - // Add a new parameter to receive the array lengths structure. - // The type is a placeholder and will be filled in later when we create the struct type. - auto* lengths = b.FunctionParam("tint_array_lengths", nullptr); - func->AppendParam(lengths); - - // Update callsites of this function to pass the structure to it. - func->ForEachUseUnsorted([&](core::ir::Usage use) { - if (auto* call = use.instruction->As()) { - // Get the structure in the calling function and pass that. - auto* caller = ContainingFunction(call); - call->AppendArg(GetArrayLengthsStructure(caller)); - } - }); - - return lengths; - }); - } - - /// Compute the array length of the runtime-sized array that is inside a storage buffer - /// variable. If the variable's binding point is not found in the bindpoint map, returns nullptr - /// to indicate that the original arrayLength builtin should be used instead. - /// - /// @param var the storage buffer variable that contains the runtime-sized array - /// @param insertion_point the insertion point for new instructions - /// @returns the length of the array, or nullptr if the original builtin should be used - Value* ComputeArrayLength(Var* var, Instruction* insertion_point) { - auto binding = var->BindingPoint(); - TINT_IR_ASSERT(ir, binding); - - auto idx_it = bindpoint_to_size_index.find(*binding); - if (idx_it == bindpoint_to_size_index.end()) { - // If the bindpoint_to_size_index map does not contain an entry for the storage buffer, - // then we preserve the arrayLength() call. - return nullptr; - } - - // Get the index of the structure member that holds the length for this binding point, - // creating the structure member descriptor if necessary. - auto member_index = bindpoint_to_length_member_index.GetOrAdd(*binding, [&]() { - auto index = static_cast(lengths_structure_members.Length()); - auto name = "tint_array_length_" + std::to_string(binding->group) + "_" + - std::to_string(binding->binding); - lengths_structure_members.Push(type::Manager::StructMemberDesc{ - .name = ir.symbols.Register(name), - .type = ty.u32(), - }); - ordered_bindpoints.Push(BindingPointInfo{ - .binding_point = *binding, - .store_type = var->Result()->Type()->UnwrapPtr(), - }); - return index; - }); - - // Extract the length from the structure. - auto* length = b.Access(GetArrayLengthsStructure(ContainingFunction(insertion_point)), - u32(member_index)); - length->InsertBefore(insertion_point); - return length->Result(); - } - - /// Create the structure to hold the array lengths and fill in the construct instruction that - /// sets all of the length values. - void CreateLengthsStructure() { - if (lengths_structure_members.IsEmpty()) { - return; - } - - // Create the lengths structure. - auto* lengths_struct = ty.Struct(ir.symbols.New("tint_array_lengths_struct"), - std::move(lengths_structure_members)); - - // Update all of the function parameters that need to receive the lengths structure. - for (auto s : function_to_lengths_structure) { - if (auto* param = s.value->As()) { - param->SetType(lengths_struct); - } - } - - // Insert code at the beginning of the entry point to initialize the array length members. - if (lengths_constructor == nullptr) { - return; - } - lengths_constructor->Result()->SetType(lengths_struct); - b.InsertBefore(lengths_constructor->Block()->Front(), [&] { - Vector constructor_values; - for (auto info : ordered_bindpoints) { - TINT_IR_ASSERT(ir, bindpoint_to_size_index.contains(info.binding_point)); - TINT_IR_ASSERT(ir, bindpoint_to_length_member_index.Contains(info.binding_point)); - - // Load the total storage buffer size from the immediate block. - // The sizes are packed into vec4s to satisfy the 16-byte alignment requirement for - // array elements in immediate block, so we have to find the vector and element that - // correspond to the index that we want. - const uint32_t size_index = bindpoint_to_size_index.at(info.binding_point); - const uint32_t array_index = size_index / 4; - const uint32_t vec_index = size_index % 4; - auto* buffer_sizes = b.Access( - ty.ptr(immediate, ty.array(ty.vec4u(), buffer_sizes_array_elements_num)), - immediate_data_layout.var, - u32(immediate_data_layout.IndexOf(buffer_sizes_offset))); - auto* vec_ptr = b.Access(ty.ptr(immediate, ty.vec4u()), buffer_sizes->Result(), - u32(array_index)); - auto* total_buffer_size = b.LoadVectorElement(vec_ptr, u32(vec_index))->Result(); - - // Calculate actual array length: - // total_buffer_size - array_offset - // array_length = -------------------------------- - // array_stride - auto* array_size = total_buffer_size; - const type::Array* array_type = nullptr; - if (auto* str = info.store_type->As()) { - // The variable is a struct, so subtract the byte offset of the array member. - auto* member = str->Members().Back(); - array_type = member->Type()->As(); - array_size = b.Subtract(total_buffer_size, u32(member->Offset()))->Result(); - } else { - array_type = info.store_type->As(); - } - TINT_IR_ASSERT(ir, array_type); - - auto* length = b.Divide(array_size, u32(array_type->ImplicitStride()))->Result(); - constructor_values.Push(length); - } - lengths_constructor->SetOperands(std::move(constructor_values)); - }); - } - - /// Get the function that contains an instruction. - /// @param inst the instruction - /// @returns the function - core::ir::Function* ContainingFunction(core::ir::Instruction* inst) { - return block_to_function.GetOrAdd(inst->Block(), [&] { // - return ContainingFunction(inst->Block()->Parent()); - }); - } - - /// @returns true if the transformed module needs a storage buffer sizes UBO - bool NeedsStorageBufferSizes() { - return !lengths_structure_members.IsEmpty() && lengths_constructor != nullptr; - } -}; - -} // namespace - -Result ArrayLengthFromImmediates( - Module& ir, - const core::ir::transform::ImmediateDataLayout& immediate_data_layout, - const uint32_t buffer_sizes_offset, - const uint32_t buffer_sizes_array_elements_num, - const std::unordered_map& bindpoint_to_size_index) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kArrayLengthFromImmediateCapabilities, - "core.ArrayLengthFromImmediates")); - - State state{ir, immediate_data_layout, buffer_sizes_offset, buffer_sizes_array_elements_num, - bindpoint_to_size_index}; - state.Process(); - - ArrayLengthFromImmediateResult result; - result.needs_storage_buffer_sizes = state.NeedsStorageBufferSizes(); - return result; -} - -} // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_uniform.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_uniform.h deleted file mode 100644 index 9eef2a4d8..000000000 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/array_length_from_uniform.h +++ /dev/null @@ -1,77 +0,0 @@ -// Copyright 2024 The Dawn & Tint Authors -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// -// 3. Neither the name of the copyright holder nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_UNIFORM_H_ -#define SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_UNIFORM_H_ - -#include - -#include "src/tint/api/common/binding_point.h" -#include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/result.h" - -// Forward declarations. -namespace tint::core::ir { -class Module; -} - -namespace tint::core::ir::transform { - -/// The capabilities that the transform can support. -const Capabilities kArrayLengthFromUniformCapabilities{Capability::kAllowDuplicateBindings}; - -/// The result of running the ArrayLengthFromUniform transform. -struct ArrayLengthFromUniformResult { - /// `true` if the transformed module needs the storage buffer sizes UBO. - bool needs_storage_buffer_sizes = false; -}; - -/// ArrayLengthFromUniform is a transform that replaces calls to the arrayLength() builtin by -/// calculating the array length from the total size of the storage buffer, which is received via a -/// uniform buffer. -/// -/// The generated uniform buffer will have the form: -/// ``` -/// @group(0) @binding(30) -/// var buffer_size_ubo : array, 8>; -/// ``` -/// The binding group and number used for this uniform buffer is provided via the transform config. -/// The transform config also defines the mapping from a storage buffer's `BindingPoint` to the -/// element index that will be used to get the size of that buffer. -/// -/// @param module the module to transform -/// @param ubo_binding the binding point to use for the uniform buffer -/// @param bindpoint_to_size_index the map from binding point to an index which holds the size -/// @returns the transform result or failure -Result ArrayLengthFromUniform( - Module& module, - BindingPoint ubo_binding, - const std::unordered_map& bindpoint_to_size_index); - -} // namespace tint::core::ir::transform - -#endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_ARRAY_LENGTH_FROM_UNIFORM_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc index ce7022272..d7a11f4da 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.cc @@ -145,8 +145,7 @@ struct State { } // namespace Result Bgra8UnormPolyfill(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kBgra8UnormPolyfillCapabilities, "core.Bgra8UnormPolyfill")); + core::ir::AssertValid(ir, "before core.Bgra8UnormPolyfill"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.h index de945ee51..a3e4d2c5a 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/bgra8unorm_polyfill.h @@ -38,13 +38,6 @@ class Module; namespace tint::core::ir::transform { -/// The capabilities that the transform can support. -const Capabilities kBgra8UnormPolyfillCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, -}; - /// Bgra8UnormPolyfill is a transform that changes the texel format of storage textures from /// bgra8unorm to rgba8unorm, inserting swizzles before and after texture accesses as necessary. /// @param module the module to transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.cc index 5ec228c48..7a1b276fd 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.cc @@ -27,6 +27,8 @@ #include "src/tint/lang/core/ir/transform/binary_polyfill.h" +#include + #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/validator.h" @@ -64,44 +66,35 @@ struct State { /// Process the module. void Process() { // Find the binary instructions that need to be polyfilled. - Vector worklist; + std::vector> worklist; + worklist.reserve(128); for (auto* inst : ir.Instructions()) { - if (auto* binary = inst->As()) { - switch (binary->Op()) { - case BinaryOp::kDivide: - case BinaryOp::kModulo: - if (config.int_div_mod && - binary->Result()->Type()->IsIntegerScalarOrVector()) { - worklist.Push(binary); - } - break; - case BinaryOp::kShiftLeft: - case BinaryOp::kShiftRight: - if (config.bitshift_modulo) { - worklist.Push(binary); - } - break; - default: - break; - } + core::ir::CoreBinary* binary = inst->As(); + if (binary == nullptr) { + continue; } - } - // Polyfill the binary instructions that we found. - for (auto* binary : worklist) { switch (binary->Op()) { case BinaryOp::kDivide: case BinaryOp::kModulo: - IntDivMod(binary); + if (config.int_div_mod && binary->Result()->Type()->IsIntegerScalarOrVector()) { + worklist.push_back([this, binary] { IntDivMod(binary); }); + } break; case BinaryOp::kShiftLeft: case BinaryOp::kShiftRight: - MaskShiftAmount(binary); + if (config.bitshift_modulo) { + worklist.push_back([this, binary] { MaskShiftAmount(binary); }); + } break; default: break; } } + + for (auto& cb : worklist) { + cb(); + } } /// Replace an integer divide or modulo with a call to helper function that prevents @@ -199,8 +192,7 @@ struct State { } // namespace Result BinaryPolyfill(Module& ir, const BinaryPolyfillConfig& config) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kBinaryPolyfillCapabilities, "core.BinaryPolyfill")); + core::ir::AssertValid(ir, kBinaryPolyfillCapabilities, "before core.BinaryPolyfill"); State{config, ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.h index c6626cd01..9c3a1967a 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/binary_polyfill.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_BINARY_POLYFILL_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -41,9 +41,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kBinaryPolyfillCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// The set of polyfills that should be applied. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.cc index 8f424880e..f580e0dbd 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.cc @@ -72,11 +72,12 @@ void Run(ir::Module& ir, const std::unordered_map& b Result BindingRemapper( Module& ir, const std::unordered_map& binding_points) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kBindingRemapperCapabilities, "core.BindingRemapper")); + core::ir::AssertValid(ir, kBindingRemapperCapabilities, "before core.BindingRemapper"); Run(ir, binding_points); + ir.properties.Add(Property::kAllowDuplicateBindings); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.h index c9348ac1b..0dffed5e4 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/binding_remapper.h @@ -47,7 +47,7 @@ namespace tint::core::ir::transform { /// bindings, so in theory shouldn't need the capability to allow /// them. const Capabilities kBindingRemapperCapabilities{ - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// BindingRemapper is a transform that remaps binding point indices and access controls. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.cc index c04dc1bc4..9216266b8 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.cc @@ -118,8 +118,8 @@ void Run(Module& ir) { } // namespace Result BlockDecoratedStructs(Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kBlockDecoratedStructsCapabilities, - "core.BlockDecoratedStructs")); + core::ir::AssertValid(ir, kBlockDecoratedStructsCapabilities, + "before core.BlockDecoratedStructs"); Run(ir); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.h index 675e4fba5..573bd79a0 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/block_decorated_structs.h @@ -40,9 +40,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kBlockDecoratedStructsCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// BlockDecoratedStructs is a transform that changes the store type of a buffer to be a special diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.cc index 33f3c1a59..6507bba11 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.cc @@ -27,7 +27,8 @@ #include "src/tint/lang/core/ir/transform/builtin_polyfill.h" -#include "src/tint/lang/core/binary_op.h" +#include + #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/validator.h" @@ -66,8 +67,10 @@ struct State { /// Process the module. void Process() { + std::vector> worklist; + worklist.reserve(128); + // Find the builtin call instructions that may need to be polyfilled. - Vector worklist; for (auto* inst : ir.Instructions()) { if (auto* builtin = inst->As()) { switch (builtin->Func()) { @@ -76,61 +79,73 @@ struct State { builtin->Result()->Type()->IsIntegerScalarOrVector()) || (config.clamp_float && builtin->Result()->Type()->IsFloatScalarOrVector())) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Clamp(builtin); }); } break; case core::BuiltinFn::kAbs: if (config.abs_signed_int && builtin->Result()->Type()->IsSignedIntegerScalarOrVector()) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { AbsSignedInt(builtin); }); } break; case core::BuiltinFn::kCountLeadingZeros: if (config.count_leading_zeros) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { CountLeadingZeros(builtin); }); } break; case core::BuiltinFn::kCountTrailingZeros: if (config.count_trailing_zeros) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { CountTrailingZeros(builtin); }); } break; case core::BuiltinFn::kDegrees: if (config.degrees) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Degrees(builtin); }); + } + break; + case core::BuiltinFn::kDistance: + if (config.distance_scalar_float && + builtin->Args()[0]->Type()->IsFloatScalar()) { + worklist.push_back([this, builtin] { DistanceScalarFloat(builtin); }); } break; case core::BuiltinFn::kSmoothstep: - worklist.Push(builtin); + worklist.push_back([this, builtin] { SmoothStep(builtin); }); break; case core::BuiltinFn::kExtractBits: if (config.extract_bits != BuiltinPolyfillLevel::kNone) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { ExtractBits(builtin); }); } break; case core::BuiltinFn::kFirstLeadingBit: if (config.first_leading_bit) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { FirstLeadingBit(builtin); }); } break; case core::BuiltinFn::kFirstTrailingBit: if (config.first_trailing_bit) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { FirstTrailingBit(builtin); }); } break; case core::BuiltinFn::kFwidthFine: if (config.fwidth_fine) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { FwidthFine(builtin); }); } break; case core::BuiltinFn::kInsertBits: if (config.insert_bits != BuiltinPolyfillLevel::kNone) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { InsertBits(builtin); }); + } + break; + case core::BuiltinFn::kLength: + if (config.length_scalar_float && + builtin->Args()[0]->Type()->IsFloatScalar()) { + worklist.push_back([this, builtin] { LengthScalarFloat(builtin); }); } break; case core::BuiltinFn::kRadians: if (config.radians) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Radians(builtin); }); } break; case core::BuiltinFn::kReflect: @@ -138,7 +153,7 @@ struct State { // Polyfill for vec2. See crbug.com/tint/1798 auto* vec_ty = builtin->Result()->Type()->As(); if (vec_ty->Width() == 2 && vec_ty->Type()->Is()) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Reflect(builtin); }); } } break; @@ -147,11 +162,12 @@ struct State { builtin->Args()[0]->Type()->DeepestElement()->Is() && builtin->Args()[0]->Type()->IsFloatVector(); if ((is_vec_f16 && config.saturate_as_min_max) || config.saturate) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Saturate(builtin); }); } - } break; + break; + } case core::BuiltinFn::kTextureSampleBias: - worklist.Push(builtin); + worklist.push_back([this, builtin] { TextureSampleBiasClamp(builtin); }); break; case core::BuiltinFn::kTextureSampleBaseClampToEdge: if (config.texture_sample_base_clamp_to_edge_2d_f32) { @@ -159,45 +175,84 @@ struct State { builtin->Args()[0]->Type()->As(); if (tex && tex->Dim() == core::type::TextureDimension::k2d && tex->Type()->Is()) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { + TextureSampleBaseClampToEdge_2d_f32(builtin); + }); } } break; - case core::BuiltinFn::kDot4U8Packed: - case core::BuiltinFn::kDot4I8Packed: { + case core::BuiltinFn::kDot4U8Packed: { if (config.dot_4x8_packed) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Dot4U8Packed(builtin); }); } break; } - case core::BuiltinFn::kPack4XI8: - case core::BuiltinFn::kPack4XU8: - case core::BuiltinFn::kPack4XI8Clamp: - case core::BuiltinFn::kUnpack4XI8: - case core::BuiltinFn::kUnpack4XU8: { + case core::BuiltinFn::kDot4I8Packed: { + if (config.dot_4x8_packed) { + worklist.push_back([this, builtin] { Dot4I8Packed(builtin); }); + } + break; + } + case core::BuiltinFn::kPack4XI8: { if (config.pack_unpack_4x8) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Pack4xI8(builtin); }); + } + break; + } + case core::BuiltinFn::kPack4XU8: { + if (config.pack_unpack_4x8) { + worklist.push_back([this, builtin] { Pack4xU8(builtin); }); + } + break; + } + case core::BuiltinFn::kPack4XI8Clamp: { + if (config.pack_unpack_4x8) { + worklist.push_back([this, builtin] { Pack4xI8Clamp(builtin); }); } break; } case core::BuiltinFn::kPack4XU8Clamp: { if (config.pack_4xu8_clamp) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Pack4xU8Clamp(builtin); }); + } + break; + } + case core::BuiltinFn::kUnpack4XI8: { + if (config.pack_unpack_4x8) { + worklist.push_back([this, builtin] { Unpack4xI8(builtin); }); + } + break; + } + case core::BuiltinFn::kUnpack4XU8: { + if (config.pack_unpack_4x8) { + worklist.push_back([this, builtin] { Unpack4xU8(builtin); }); } break; } case core::BuiltinFn::kPack4X8Snorm: + if (config.pack_unpack_4x8_norm) { + worklist.push_back([this, builtin] { Pack4x8Snorm(builtin); }); + } + break; case core::BuiltinFn::kPack4X8Unorm: + if (config.pack_unpack_4x8_norm) { + worklist.push_back([this, builtin] { Pack4x8Unorm(builtin); }); + } + break; case core::BuiltinFn::kUnpack4X8Snorm: + if (config.pack_unpack_4x8_norm) { + worklist.push_back([this, builtin] { Unpack4x8Snorm(builtin); }); + } + break; case core::BuiltinFn::kUnpack4X8Unorm: if (config.pack_unpack_4x8_norm) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { Unpack4x8Unorm(builtin); }); } break; case core::BuiltinFn::kSubgroupBroadcast: if (config.subgroup_broadcast_f16 && builtin->Result()->Type()->DeepestElement()->Is()) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { SubgroupBroadcast(builtin); }); } break; default: @@ -206,99 +261,8 @@ struct State { } } - // Polyfill the builtin call instructions that we found. - for (auto* builtin : worklist) { - switch (builtin->Func()) { - case core::BuiltinFn::kClamp: - Clamp(builtin); - break; - case core::BuiltinFn::kAbs: - AbsSignedInt(builtin); - break; - case core::BuiltinFn::kCountLeadingZeros: - CountLeadingZeros(builtin); - break; - case core::BuiltinFn::kCountTrailingZeros: - CountTrailingZeros(builtin); - break; - case core::BuiltinFn::kDegrees: - Degrees(builtin); - break; - case core::BuiltinFn::kSmoothstep: - SmoothStep(builtin); - break; - case core::BuiltinFn::kExtractBits: - ExtractBits(builtin); - break; - case core::BuiltinFn::kFirstLeadingBit: - FirstLeadingBit(builtin); - break; - case core::BuiltinFn::kFirstTrailingBit: - FirstTrailingBit(builtin); - break; - case core::BuiltinFn::kFwidthFine: - FwidthFine(builtin); - break; - case core::BuiltinFn::kInsertBits: - InsertBits(builtin); - break; - case core::BuiltinFn::kRadians: - Radians(builtin); - break; - case core::BuiltinFn::kReflect: - Reflect(builtin); - break; - case core::BuiltinFn::kSaturate: - Saturate(builtin); - break; - case core::BuiltinFn::kTextureSampleBaseClampToEdge: - TextureSampleBaseClampToEdge_2d_f32(builtin); - break; - case core::BuiltinFn::kTextureSampleBias: - TextureSampleBiasClamp(builtin); - break; - case core::BuiltinFn::kDot4I8Packed: - Dot4I8Packed(builtin); - break; - case core::BuiltinFn::kDot4U8Packed: - Dot4U8Packed(builtin); - break; - case core::BuiltinFn::kPack4XI8: - Pack4xI8(builtin); - break; - case core::BuiltinFn::kPack4XU8: - Pack4xU8(builtin); - break; - case core::BuiltinFn::kPack4XI8Clamp: - Pack4xI8Clamp(builtin); - break; - case core::BuiltinFn::kPack4XU8Clamp: - Pack4xU8Clamp(builtin); - break; - case core::BuiltinFn::kUnpack4XI8: - Unpack4xI8(builtin); - break; - case core::BuiltinFn::kUnpack4XU8: - Unpack4xU8(builtin); - break; - case core::BuiltinFn::kPack4X8Snorm: - Pack4x8Snorm(builtin); - break; - case core::BuiltinFn::kPack4X8Unorm: - Pack4x8Unorm(builtin); - break; - case core::BuiltinFn::kUnpack4X8Snorm: - Unpack4x8Snorm(builtin); - break; - case core::BuiltinFn::kUnpack4X8Unorm: - Unpack4x8Unorm(builtin); - break; - case core::BuiltinFn::kSubgroupBroadcast: - SubgroupBroadcast(builtin); - break; - default: - break; - } + for (auto& cb : worklist) { + cb(); } } @@ -559,6 +523,17 @@ struct State { call->Destroy(); } + /// Polyfill a `distance()` builtin call for scalar f32 and f16. + /// @param call the builtin call instruction + void DistanceScalarFloat(ir::CoreBuiltinCall* call) { + // distance(x, y) -> abs(x - y) + b.InsertBefore(call, [&] { + auto* sub = b.Subtract(call->Args()[0], call->Args()[1]); + b.CallWithResult(call->DetachResult(), core::BuiltinFn::kAbs, sub); + }); + call->Destroy(); + } + /// Polyfill an `smoothStep()` builtin call. /// @param call the builtin call instruction void SmoothStep(ir::CoreBuiltinCall* call) { @@ -668,7 +643,7 @@ struct State { b.InsertBefore(call, [&] { // %x = %input; // if (%x is signed) { - // %x = select(u32(%x), ~u32(%x), x > 0x80000000); + // %x = select(~u32(%x), u32(%x), u32(x) < 0x80000000); // } // %b16 = select(16, 0, (%x & 0xffff0000) == 0); // %x >>= %b16; @@ -863,6 +838,16 @@ struct State { } } + /// Polyfill a `length()` builtin call for scalar f32 and f16. + /// @param call the builtin call instruction + void LengthScalarFloat(ir::CoreBuiltinCall* call) { + // length(x) -> abs(x) + b.InsertBefore(call, [&] { + b.CallWithResult(call->DetachResult(), core::BuiltinFn::kAbs, call->Args()[0]); + }); + call->Destroy(); + } + /// Polyfill an `radians()` builtin call. /// @param call the builtin call instruction void Radians(ir::CoreBuiltinCall* call) { @@ -927,9 +912,9 @@ struct State { one = b.MatchWidth(1_h, type); } - // Intel mesa incorrectly performs saturate on vec f16 loads from uniforms. + // Intel Mesa incorrectly performs saturate on vec f16 loads from uniforms. // Note: to avoid compiler pattern matching, we do the min then the max which is - // functionally different than doing the max then the min for high/low swapped (this doesnt + // functionally different than doing the max then the min for high/low swapped (this doesn't // matter in the case with saturate). See crbug.com/448873316 if (config.saturate_as_min_max && is_vec_f16) { b.InsertBefore(call, [&] { @@ -1243,8 +1228,7 @@ struct State { } // namespace Result BuiltinPolyfill(Module& ir, const BuiltinPolyfillConfig& config) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kBuiltinPolyfillCapabilities, "core.BuiltinPolyfill")); + core::ir::AssertValid(ir, kBuiltinPolyfillCapabilities, "before core.BuiltinPolyfill"); State{config, ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.h index 8eff88e70..93e0f81fc 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_polyfill.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_BUILTIN_POLYFILL_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -41,9 +41,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kBuiltinPolyfillCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// Enumerator of polyfill levels. @@ -56,6 +54,26 @@ enum class BuiltinPolyfillLevel { kFull, }; +/// @param out the stream to write to +/// @param level the polyfill level +/// @returns @p out so calls can be chained +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, BuiltinPolyfillLevel level) { + switch (level) { + case BuiltinPolyfillLevel::kNone: + out << "none"; + break; + case BuiltinPolyfillLevel::kClampOrRangeCheck: + out << "clamp_or_range_check"; + break; + case BuiltinPolyfillLevel::kFull: + out << "full"; + break; + } + return out; +} + /// The set of polyfills that should be applied. struct BuiltinPolyfillConfig { /// Should `clamp()` be polyfilled for integer values? @@ -70,6 +88,8 @@ struct BuiltinPolyfillConfig { bool count_trailing_zeros = false; /// Should `degrees()` be polyfilled? bool degrees = false; + /// Should `distance()` be polyfilled for scalar f32 and f16? + bool distance_scalar_float = false; /// How should `extractBits()` be polyfilled? BuiltinPolyfillLevel extract_bits = BuiltinPolyfillLevel::kNone; /// Should `firstLeadingBit()` be polyfilled? @@ -80,6 +100,8 @@ struct BuiltinPolyfillConfig { bool fwidth_fine = false; /// How should `insertBits()` be polyfilled? BuiltinPolyfillLevel insert_bits = BuiltinPolyfillLevel::kNone; + /// Should `length()` be polyfilled for scalar f32 and f16? + bool length_scalar_float = false; /// Should `radians()` be polyfilled? bool radians = false; /// Should `reflect()` be polyfilled for vec2? @@ -100,20 +122,24 @@ struct BuiltinPolyfillConfig { bool pack_unpack_4x8_norm = false; /// Should `subgroupBroadcast(f16)` be polyfilled? bool subgroup_broadcast_f16 = false; - // Should 'saturate(f16)' be polyfilled with min and max. + /// Should 'saturate(f16)' be polyfilled with min and max. bool saturate_as_min_max = false; /// Reflection for this class TINT_REFLECT(BuiltinPolyfillConfig, clamp_int, + clamp_float, + abs_signed_int, count_leading_zeros, count_trailing_zeros, degrees, + distance_scalar_float, extract_bits, first_leading_bit, first_trailing_bit, fwidth_fine, insert_bits, + length_scalar_float, radians, reflect_vec2_f32, saturate, diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.cc index ca5e4a9f6..0804ff257 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.cc @@ -72,11 +72,9 @@ struct State { } switch (builtin_enum) { case core::BuiltinFn::kClamp: - return config.scalarize_clamp; case core::BuiltinFn::kMax: - return config.scalarize_max; case core::BuiltinFn::kMin: - return config.scalarize_min; + return config.scalarize_min_max_clamp; default: return false; } @@ -135,11 +133,14 @@ struct State { } // namespace Result BuiltinScalarize(Module& ir, const BuiltinScalarizeConfig& config) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kBuiltinScalarizeCapabilities, "core.BuiltinScalarize")); + core::ir::AssertValid(ir, kBuiltinScalarizeCapabilities, "before core.BuiltinScalarize"); State{config, ir}.Process(); + if (config.scalarize_min_max_clamp) { + ir.properties.Add(Property::kDisallowVectorMinMaxClamp); + } + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.h index 63bb55456..a59ad4ff2 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/builtin_scalarize.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_BUILTIN_SCALARIZE_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -41,33 +41,17 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kBuiltinScalarizeCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, core::ir::Capability::kAllow64BitIntegers, - core::ir::Capability::kAllowPointSizeBuiltin, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowAnyLetType, - core::ir::Capability::kMslAllowEntryPointInterface, - core::ir::Capability::kAllowModuleScopeLets, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, }; /// The scalarizer configuration options struct BuiltinScalarizeConfig { - // Set to true to scalarize clamp builtin - bool scalarize_clamp = false; - - // Set to true to scalarize max builtin - bool scalarize_max = false; - - // Set to true to scalarize min builtin - bool scalarize_min = false; + // Set to true to scalarize min/max/clamp builtins. + bool scalarize_min_max_clamp = false; /// Reflection for this class - TINT_REFLECT(BuiltinScalarizeConfig, scalarize_clamp, scalarize_max, scalarize_min); + TINT_REFLECT(BuiltinScalarizeConfig, scalarize_min_max_clamp); }; /// BuiltinScalarize is a transform that replaces calls to builtin vector functions with scalar diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/change_immediate_to_uniform.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/change_immediate_to_uniform.cc index ebcf0ca64..fecfdb74d 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/change_immediate_to_uniform.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/change_immediate_to_uniform.cc @@ -147,17 +147,11 @@ struct State { Result ChangeImmediateToUniform(core::ir::Module& ir, const ChangeImmediateToUniformConfig& config) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllow8BitIntegers, - core::ir::Capability::kAllowPointSizeBuiltin, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kMslAllowEntryPointInterface, - }, - "core.ChangeImmediateToUniform")); + core::ir::AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + }, + "before core.ChangeImmediateToUniform"); State{config, ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/collapse_subgroup_min_max.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/collapse_subgroup_min_max.cc new file mode 100644 index 000000000..ac11d36eb --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/collapse_subgroup_min_max.cc @@ -0,0 +1,86 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/tint/lang/core/ir/transform/collapse_subgroup_min_max.h" + +#include "src/tint/lang/core/ir/builder.h" +#include "src/tint/lang/core/ir/module.h" +#include "src/tint/lang/core/ir/validator.h" + +namespace tint::core::ir::transform { + +namespace { + +bool IsCollapsibleSubgroupOp(core::BuiltinFn func) { + return (func == core::BuiltinFn::kSubgroupMin) || (func == core::BuiltinFn::kSubgroupMax); +} + +// Helper to check if a value is the result of a collapsible subgroup operation, +// possibly through "let" instructions. +bool IsCollapsibleSubgroupValue(core::ir::Value* value) { + while (auto* res = value->As()) { + auto* inst = res->Instruction(); + if (auto* let = inst->As()) { + value = let->Value(); + continue; + } + if (auto* call = inst->As()) { + return IsCollapsibleSubgroupOp(call->Func()); + } + break; + } + return false; +} + +void Process(Module& ir) { + // Add all nested subgroupMin/Max calls that can be collapsed to a worklist. + Vector worklist; + for (auto* inst : ir.Instructions()) { + if (auto* call = inst->As()) { + if (IsCollapsibleSubgroupOp(call->Func())) { + if (IsCollapsibleSubgroupValue(call->Args()[0])) { + worklist.Push(call); + } + } + } + } + + // Replace outer call with inner result. + for (auto* call : worklist) { + call->Result(0)->ReplaceAllUsesWith(call->Args()[0]); + call->Destroy(); + } +} + +} // namespace + +Result CollapseSubgroupMinMax(Module& ir) { + Process(ir); + return Success; +} + +} // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/collapse_subgroup_min_max.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/collapse_subgroup_min_max.h new file mode 100644 index 000000000..352697db4 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/collapse_subgroup_min_max.h @@ -0,0 +1,49 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_CORE_IR_TRANSFORM_COLLAPSE_SUBGROUP_MIN_MAX_H_ +#define SRC_TINT_LANG_CORE_IR_TRANSFORM_COLLAPSE_SUBGROUP_MIN_MAX_H_ + +#include "src/tint/utils/result.h" + +// Forward declarations. +namespace tint::core::ir { +class Module; +} + +namespace tint::core::ir::transform { + +/// CollapseSubgroupMinMax is a transform that replaces calls to subgroupMin and +/// subgroupMax builtins with their argument if that argument is also a subgroupMin/Max call which +/// is then by definition subgroup uniform. +/// @param module the module to transform +/// @returns success or failure +Result CollapseSubgroupMinMax(Module& module); + +} // namespace tint::core::ir::transform + +#endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_COLLAPSE_SUBGROUP_MIN_MAX_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/combine_access_instructions.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/combine_access_instructions.cc index 937918d2d..addc5b2fe 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/combine_access_instructions.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/combine_access_instructions.cc @@ -80,13 +80,7 @@ struct State { } // namespace Result CombineAccessInstructions(Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, - }, - "core.CombineAccessInstructions")); + core::ir::AssertValid(ir, "before core.CombineAccessInstructions"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.cc index 107c4bfdf..53b3128d9 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.cc @@ -165,8 +165,7 @@ struct State { } // namespace Result ConversionPolyfill(Module& ir, const ConversionPolyfillConfig& config) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kConversionPolyfillCapabilities, "core.ConversionPolyfill")); + core::ir::AssertValid(ir, kConversionPolyfillCapabilities, "before core.ConversionPolyfill"); State{config, ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.h index efc183a9c..3057545d3 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/conversion_polyfill.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_CONVERSION_POLYFILL_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -41,9 +41,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kConversionPolyfillCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// The set of polyfills that should be applied. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.cc index 6643c6150..029200679 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.cc @@ -105,11 +105,12 @@ struct State { } // namespace Result DeadCodeElimination(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kDeadCodeEliminationCapabilities, "core.DeadCodeElimination")); + core::ir::AssertValid(ir, kDeadCodeEliminationCapabilities, "before core.DeadCodeElimination"); State{ir}.Process(); + ir.properties.Remove(Property::kAllowUnannotatedModuleIOVariables); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.h index 1c73d8a12..3f4b61fdb 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/dead_code_elimination.h @@ -40,15 +40,6 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kDeadCodeEliminationCapabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowPhonyInstructions, - core::ir::Capability::kAllowUnannotatedModuleIOVariables, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowStructMatrixDecorations, - core::ir::Capability::kAllowLocationForNumericElements, - core::ir::Capability::kAllowPointerToHandle, core::ir::Capability::kLoosenValidationForShaderIO, }; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/decompose_access.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/decompose_access.cc index d3c16e79f..337a38d7e 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/decompose_access.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/decompose_access.cc @@ -68,8 +68,15 @@ struct State { const type::Type* base_ty_ = nullptr; const type::Pointer* base_ptr_ty_ = nullptr; + diag::Diagnostic MakeError(const Source& src) { + diag::Diagnostic error{}; + error.severity = diag::Severity::Error; + error.source = src; + return error; + } + /// Process the module. - void Process() { + diag::Result Process() { Vector var_worklist; for (auto* inst : *ir.root_block) { // Allow this to run before or after PromoteInitializers by handling non-var root_block @@ -103,10 +110,24 @@ struct State { for (auto* var : var_worklist) { auto* result = var->Result(); + auto* var_ty = result->Type()->As(); SetBaseEleType(var); + // Figure the final type early to check for potential size issues. + const type::Array* array_ty = nullptr; + if (!var_ty->StoreType()->HasFixedFootprint()) { + // Use a runtime-sized array of the base type. + array_ty = ty.runtime_array(BaseEleType()); + } else { + TINT_CHECK_RESULT_UNWRAP(array_length, + NumBaseElementsChecked(var_ty->StoreType(), var)); + + array_length = + std::max(array_length, options.minimum_array_size / BaseEleType()->Size()); + array_ty = ty.array(BaseEleType(), array_length); + } + auto usage_worklist = result->UsagesSorted(); - auto* var_ty = result->Type()->As(); while (!usage_worklist.IsEmpty()) { auto usage = usage_worklist.Pop(); auto* inst = usage.instruction; @@ -143,6 +164,7 @@ struct State { BufferLength(call, var, var_ty->StoreType()); break; case core::BuiltinFn::kBufferView: + case core::BuiltinFn::kBufferArrayView: BufferView(call, var, var_ty->StoreType(), {}); break; default: @@ -152,40 +174,11 @@ struct State { TINT_ICE_ON_NO_MATCH); } - auto HasRuntimeSize = [&](const type::Type* type) { - return tint::Switch( - type, - [&](const type::Array* arr) { - return arr->Count()->Is(); - }, - [&](const type::Buffer* buf) { - return buf->Count()->Is(); - }, - [&](const type::Struct* str) { - auto* last = - str->Element(static_cast(str->Members().Length()) - 1); - if (auto* arr = last->As()) { - return arr->Count()->Is(); - } - return false; - }, - [&](Default) { return false; }); - }; - // Swap the result type of the `var` to the new result type - const type::Array* array_ty = nullptr; - if (HasRuntimeSize(var_ty->StoreType())) { - // Use a runtime-sized array of the base type. - array_ty = ty.runtime_array(BaseEleType()); - } else { - auto array_length = NumBaseElements(var_ty->StoreType()); - - array_length = - std::max(array_length, options.minimum_array_size / BaseEleType()->Size()); - array_ty = ty.array(BaseEleType(), array_length); - } result->SetType(ty.ptr(var_ty->AddressSpace(), array_ty, var_ty->Access())); } + + return Success; } const type::Type* BaseEleType() { return base_ty_; } @@ -193,16 +186,45 @@ struct State { const type::Pointer* BaseEleTypePtr() { return base_ptr_ty_; } // Returns the number of BaseEleType elements need to represent `type` rounded up. + diag::Result NumBaseElementsChecked(const type::Type* type, + Instruction* source_inst) { + uint64_t num_elements = static_cast(type->Size()); + num_elements = (num_elements + BaseEleType()->Size() - 1) / BaseEleType()->Size(); + if (num_elements > std::numeric_limits::max()) { + diag::Diagnostic error = MakeError(ir.SourceOf(source_inst)); + error << "required array size (" << num_elements << ") is too large"; + return diag::Failure(error); + } + return static_cast(num_elements); + } + uint32_t NumBaseElements(const type::Type* type) { - return (type->Size() + BaseEleType()->Size() - 1) / BaseEleType()->Size(); + uint64_t num_elements = static_cast(type->Size()); + num_elements = (num_elements + BaseEleType()->Size() - 1) / BaseEleType()->Size(); + return static_cast(num_elements); } // OffsetData represents an unsigned integer expression. // The value is the sum of a const part, held in `byte_offset`, and // non-const parts in `byte_offset_expr`. + // + // It also contains information encoding for buffer_view functions. struct OffsetData { uint32_t byte_offset = 0; Vector byte_offset_expr{}; + + // The byte offset of the runtime array part of a struct. + // Note: this is also encoded as part of byte_offset, but is needed separately for + // bufferArrayView. + uint32_t byte_struct_offset = 0; + + // The byte size of a bufferArrayView call + uint32_t byte_size = 0; + core::ir::Value* byte_size_expr = nullptr; + + // The byte length of a bufferView or bufferArrayView call + uint32_t byte_length = 0; + core::ir::Value* byte_length_expr = nullptr; }; bool ContainsAtomic(const type::Type* type) const { @@ -226,7 +248,7 @@ struct State { type, // [&](const type::Scalar* scalar) { return scalar->Size(); }, [&](const type::Vector* vector) { - if (vector->Width() == 3) { + if (vector->Width() == 3 || vector->Type()->Is()) { return vector->Type()->Size(); } return type->Size(); @@ -266,7 +288,8 @@ struct State { [&](core::ir::Instruction* inst) { bool bufferView = false; if (auto* call = inst->As()) { - bufferView = call->Func() == core::BuiltinFn::kBufferView; + bufferView = call->Func() == core::BuiltinFn::kBufferView || + call->Func() == core::BuiltinFn::kBufferArrayView; } if (inst->IsAnyOf() || bufferView) { for (auto u : inst->Result()->UsagesSorted()) { @@ -357,32 +380,96 @@ struct State { // correct vector array element in the underlying variable. core::ir::Value* CalculateVectorOffset(core::ir::Value* byte_idx, const type::Vector* src_ty) { if (auto* byte_cnst = byte_idx->As()) { - return b.Value( - u32((byte_cnst->Value()->ValueAs() % src_ty->Size()) / src_ty->Width())); + return b.Value(u32((byte_cnst->Value()->ValueAs() % src_ty->Size()) / + src_ty->Type()->Size())); } // Note: Using bitwise-and and shift instead of modulo and divide here was necessary to // avoid an FXC miscompile. See https://crbug.com/454366353. return b .ShiftRight(b.And(byte_idx, b.Constant(u32(src_ty->Size() - 1))), - u32(log2(src_ty->Width()))) + u32(log2(src_ty->Type()->Size()))) ->Result(); } // Note, must be called inside a builder insert block (Append, InsertBefore, etc) - void UpdateOffsetData(core::ir::Value* v, uint32_t elm_size, OffsetData* offset) { + void UpdateOffsetData(core::ir::Value* v, uint32_t elm_size, OffsetData* data) { tint::Switch( v, // [&](core::ir::Constant* idx_value) { - offset->byte_offset += idx_value->Value()->ValueAs() * elm_size; + data->byte_offset += idx_value->Value()->ValueAs() * elm_size; }, [&](core::ir::Value* val) { auto* idx = val; idx = b.InsertConvertIfNeeded(ty.u32(), val); - offset->byte_offset_expr.Push(b.Multiply(idx, u32(elm_size))->Result()); + data->byte_offset_expr.Push(b.Multiply(idx, u32(elm_size))->Result()); }, TINT_ICE_ON_NO_MATCH); } + // Note, must be called inside a builder insert block (Append, InsertBefore, etc) + // Note, size is always in bytes. + void UpdateSizeData(core::ir::Value* v, OffsetData* data) { + tint::Switch( + v, // + [&](core::ir::Constant* idx_value) { + TINT_IR_ASSERT(ir, data->byte_size == 0); + data->byte_size = idx_value->Value()->ValueAs(); + }, + [&](core::ir::Value* val) { + TINT_IR_ASSERT(ir, data->byte_size_expr == nullptr); + auto* idx = val; + idx = b.InsertConvertIfNeeded(ty.u32(), val); + data->byte_size_expr = idx; + }, + TINT_ICE_ON_NO_MATCH); + } + + // Note, must be called inside a builder insert block (Append, InsertBefore, etc) + core::ir::Value* SizeToValue(OffsetData* data) { + if (data->byte_size_expr) { + TINT_IR_ASSERT(ir, data->byte_size == 0); + return data->byte_size_expr; + } + return b.Constant(u32(data->byte_size)); + } + + /// @returns true if data has size information. + bool HasSizeData(const OffsetData& data) { + return data.byte_size != 0 || data.byte_size_expr != nullptr; + } + + // Note, must be called inside a builder insert block (Append, InsertBefore, etc) + // Note, length is always in bytes. + void UpdateLengthData(core::ir::Value* v, OffsetData* data) { + tint::Switch( + v, // + [&](core::ir::Constant* idx_value) { + TINT_IR_ASSERT(ir, data->byte_length == 0); + data->byte_length = idx_value->Value()->ValueAs(); + }, + [&](core::ir::Value* val) { + TINT_IR_ASSERT(ir, data->byte_length_expr == nullptr); + auto* idx = val; + idx = b.InsertConvertIfNeeded(ty.u32(), val); + data->byte_length_expr = idx; + }, + TINT_ICE_ON_NO_MATCH); + } + + // Note, must be called inside a builder insert block (Append, InsertBefore, etc) + core::ir::Value* LengthToValue(OffsetData* data) { + if (data->byte_length_expr) { + TINT_IR_ASSERT(ir, data->byte_length == 0); + return data->byte_length_expr; + } + return b.Constant(u32(data->byte_length)); + } + + /// @returns true if data has length information. + bool HasLengthData(const OffsetData& data) { + return data.byte_length != 0 || data.byte_length_expr != nullptr; + } + void Access(core::ir::Access* a, core::ir::Var* var, const core::type::Type* obj_ty, @@ -422,6 +509,11 @@ struct State { auto* mem = s->Members()[idx]; obj_ty = mem->Type(); offset.byte_offset += mem->Offset(); + if (!a->Result()->Type()->UnwrapPtr()->HasFixedFootprint()) { + // Also track the struct offset separately. + TINT_IR_ASSERT(ir, offset.byte_struct_offset == 0); + offset.byte_struct_offset = mem->Offset(); + } }, TINT_ICE_ON_NO_MATCH); } @@ -432,12 +524,22 @@ struct State { void BufferView(core::ir::CoreBuiltinCall* call, core::ir::Var* var, const type::Type* obj_type, - OffsetData offset) { - auto* offset_arg = call->Args()[1]; - b.InsertBefore(call, [&] { UpdateOffsetData(offset_arg, 1, &offset); }); + OffsetData data) { + b.InsertBefore(call, [&] { + // Record offset, size (for bufferArrayView), and length (if present). + UpdateOffsetData(call->Args()[1], 1, &data); + if (call->Func() == core::BuiltinFn::kBufferArrayView) { + UpdateSizeData(call->Args()[2], &data); + if (call->Args().size() > 3) { + UpdateLengthData(call->Args()[3], &data); + } + } else if (call->Args().size() > 2) { + UpdateLengthData(call->Args()[2], &data); + } + }); obj_type = call->Result()->Type()->As()->StoreType(); - AccessUses(call, var, obj_type, offset); + AccessUses(call, var, obj_type, data); } void AccessUses(core::ir::Instruction* inst, @@ -494,6 +596,16 @@ struct State { } void Load(core::ir::Load* ld, core::ir::Var* var, OffsetData offset) { + // Skip unused array loads from workgroup phony assignments (e.g. `_ = workgroup_var;`). + // Only arrays generate expensive loop helpers. The var stays in root block scope to + // preserve groupshared/static declarations. + if (!ld->Result()->IsUsed() && ld->Result()->Type()->Is()) { + auto* var_ty = var->Result()->Type()->As(); + if (var_ty && var_ty->AddressSpace() == AddressSpace::kWorkgroup) { + ld->Destroy(); + return; + } + } b.InsertBefore(ld, [&] { auto* byte_idx = OffsetToValue(offset); auto* result = MakeLoad(ld, var, ld->Result()->Type(), byte_idx); @@ -1001,13 +1113,18 @@ struct State { void ArrayLength(core::ir::CoreBuiltinCall* call, core::ir::Var* var, const type::Type* type, - OffsetData offset) { + OffsetData data) { auto* array_ty = type->As(); TINT_IR_ASSERT(ir, array_ty && array_ty->Count()->Is()); + auto* ptr_ty = var->Result()->Type()->As(); // The arrayLength of the transformed variable will always be a multiple of the base type. - TINT_IR_ASSERT(ir, array_ty->ElemType()->Size() / BaseEleType()->Size() >= 1); - const uint32_t ratio = array_ty->ImplicitStride() / BaseEleType()->Size(); + TINT_IR_ASSERT(ir, ptr_ty->AddressSpace() != core::AddressSpace::kStorage || + array_ty->ElemType()->Size() / BaseEleType()->Size() >= 1); + uint32_t ratio = 1; + if (ptr_ty->AddressSpace() == core::AddressSpace::kStorage) { + ratio = array_ty->ImplicitStride() / BaseEleType()->Size(); + } // Given: // b = bufferView var, offset1 @@ -1019,31 +1136,76 @@ struct State { // o = add offset1, bytes(offset2) // s = sub l, o // d = div s, ratio + // + // Given: + // b = bufferArrayView var, offset1, size + // a = access b, offset2 + // l = arrayLength a + // + // Transformed: + // l = size + // s = sub l, offset2 + // d = div s, array_stride + // + // Given: + // b = bufferView var, offset1, length + // a = access b, offset2 + // l = arrayLength a + // + // Transformed: + // l = length + // s = sub l, offset2 + // d = div s, array_stride b.InsertBefore(call, [&] { - // Re-create the arrayLength call to simplify RAUW below. - auto* len = b.Call(ty.u32(), BuiltinFn::kArrayLength, var); + bool has_size = HasSizeData(data); + bool has_length = HasLengthData(data); + core::ir::Value* len = nullptr; + if (has_size) { + len = SizeToValue(&data); + } else if (has_length) { + len = LengthToValue(&data); + } else { + TINT_IR_ASSERT(ir, ptr_ty->AddressSpace() != core::AddressSpace::kUniform && + ptr_ty->AddressSpace() != core::AddressSpace::kWorkgroup); + // Re-create the arrayLength call to simplify RAUW below. + len = b.Call(ty.u32(), BuiltinFn::kArrayLength, var)->Result(); + } Value* value = nullptr; - ir::Instruction* inst = len; - // bufferView calls may have introduced a single runtime offset value. - TINT_IR_ASSERT(ir, offset.byte_offset_expr.Length() <= 1); - if (offset.byte_offset > 0 && offset.byte_offset_expr.Length() > 0) { - value = b.Add(offset.byte_offset_expr[0], u32(offset.byte_offset))->Result(); - } else if (offset.byte_offset_expr.Length() > 0) { - value = offset.byte_offset_expr[0]; - } else if (offset.byte_offset > 0) { - value = b.Constant(u32(offset.byte_offset / BaseEleType()->Size())); - } - if (value && offset.byte_offset_expr.Length() > 0) { - value = b.Divide(value, u32(BaseEleType()->Size()))->Result(); + // buffer[Array]View calls may have introduced a single runtime offset value. + TINT_IR_ASSERT(ir, data.byte_offset_expr.Length() <= 1); + if (has_size) { + // bufferArrayView call preceded this. We can't just use the accumulated offset + // since that includes the offset in view call. Instead we only want any struct + // offset that was encountered. + if (data.byte_struct_offset != 0) { + value = b.Constant(u32(data.byte_struct_offset)); + } + } else if (has_length) { + // A length was encoded in bytes so use offset directly. + value = OffsetToValue(data); + } else { + if (data.byte_offset > 0 && data.byte_offset_expr.Length() > 0) { + value = b.Add(data.byte_offset_expr[0], u32(data.byte_offset))->Result(); + } else if (data.byte_offset_expr.Length() > 0) { + value = data.byte_offset_expr[0]; + } else if (data.byte_offset > 0) { + value = b.Constant(u32(data.byte_offset / BaseEleType()->Size())); + } + if (value && data.byte_offset_expr.Length() > 0) { + value = b.Divide(value, u32(BaseEleType()->Size()))->Result(); + } } if (value) { - inst = b.Subtract(inst, value); + len = b.Subtract(len, value)->Result(); } - if (ratio != 1u) { - inst = b.Divide(inst, u32(ratio)); + if (has_size || has_length) { + // The calculations are in bytes, so use the array stride here. + len = b.Divide(len, u32(array_ty->ImplicitStride()))->Result(); + } else if (ratio != 1u) { + len = b.Divide(len, u32(ratio))->Result(); } - call->Result()->ReplaceAllUsesWith(inst->Result()); + call->Result()->ReplaceAllUsesWith(len); }); call->Destroy(); } @@ -1059,7 +1221,7 @@ struct State { TINT_IR_ASSERT(ir, buffer_ty && (buffer_ty->Count()->Is() || buffer_ty->Count()->Is())); - if (call->Args().Length() > 1) { + if (call->Args().size() > 1) { // Direct variable access encoded a lower limit. call->Result()->ReplaceAllUsesWith(call->Args()[1]); } else if (auto* cnst = buffer_ty->Count()->As()) { @@ -1123,7 +1285,10 @@ struct State { // 1. The base type is a vector. // i. If a single store is needed, we simply cast the result if necessary // ii. Multiple stores are needed, break the vector in sub-vectors and store those. - // 2. The base type is a scalar. Store each element at successive indices. + // 2. The base type is a scalar. + // i. If the vector element is smaller than base type (e.g., vec4h with u32 base), + // bitcast the entire vector to u32(s) and store. + // ii. Otherwise, store each element at successive indices. void MakeVectorStore(core::ir::Var* var, core::ir::Value* from, core::ir::Value* byte_idx) { auto* st_ty = from->Type()->As(); // Number of array elements need to store the scalar. @@ -1160,6 +1325,43 @@ struct State { } } else { auto* st_ele_ty = st_ty->DeepestElement(); + + // Case A: Vector element is smaller than base type. + // This occurs when storing vec but the base type is u32. + if (st_ele_ty->Size() < BaseEleType()->Size()) { + TINT_IR_ASSERT(ir, BaseEleType()->Is()); + TINT_IR_ASSERT(ir, st_ele_ty->Size() == 2); // f16 or similar 2-byte type + + // vec3 forces a u16 base type, so width must be even here. + TINT_IR_ASSERT(ir, st_ty->Width() % 2 == 0); + + // vec2h -> bitcast to u32, vec4h -> bitcast to vec2u + uint32_t num_u32s = (st_ty->Width() == 2) ? 1 : 2; + Value* cast_val = (num_u32s == 1) ? b.Bitcast(ty.u32(), from)->Result() + : b.Bitcast(ty.vec2u(), from)->Result(); + + for (uint32_t i = 0; i < num_u32s; i++) { + Value* elem = + (num_u32s == 1) ? cast_val : b.Access(ty.u32(), cast_val, u32(i))->Result(); + auto* access = b.Access(BaseEleTypePtr(), var, array_idx); + b.Store(access, elem); + if (i < num_u32s - 1) { + if (auto* cnst = array_idx->As()) { + array_idx = b.Constant(u32(cnst->Value()->ValueAs() + 1)); + } else { + array_idx = b.Add(array_idx, 1_u)->Result(); + } + } + } + return; + } + + // Case B: Vector element is equal to or larger than base type. + // ratio == 1: element size == base type size. + // e.g. vec4 with u32 base → 4× u32 (bitcast each f32) + // ratio == 2: element size is 2× base type size. + // e.g. vec4 with u16 base → 8× u16 (bitcast vec4 to vec2, then + // bitcast each u32 to 2× u16) uint32_t ratio = st_ele_ty->Size() / BaseEleType()->Size(); TINT_IR_ASSERT(ir, ratio == 1 || ratio == 2); for (uint32_t i = 0; i < num_array_eles; i++) { @@ -1224,6 +1426,7 @@ struct State { auto* byte_idx = OffsetToValue(offset); MakeStore(s, var, s->Value(), byte_idx); }); + s->Destroy(); } // Create a store function for the given `var` and `struct` combination. Essentially creates a @@ -1329,20 +1532,17 @@ struct State { } // namespace Result DecomposeAccess(core::ir::Module& ir, const DecomposeAccessOptions& options) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllow8BitIntegers, - core::ir::Capability::kAllow16BitIntegers, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kLoosenValidationForShaderIO, - }, - "core.DecomposeUniformAccess")); + core::ir::AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + core::ir::Capability::kLoosenValidationForShaderIO, + }, + "before core.DecomposeAccess"); - State{ir, options}.Process(); + auto res = State{ir, options}.Process(); + if (res != Success) { + return Failure{res.Failure().reason.Str()}; + } return Success; } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.cc index 7935f2738..b7a4a0791 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.cc @@ -214,8 +214,7 @@ struct State { } // namespace Result DemoteToHelper(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kDemoteToHelperCapabilities, "core.DemoteToHelper")); + core::ir::AssertValid(ir, kDemoteToHelperCapabilities, "before core.DemoteToHelper"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.h index 6bb3f7c52..3638f687a 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/demote_to_helper.h @@ -40,11 +40,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kDemoteToHelperCapabilities{ - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, }; /// DemoteToHelper is a transform that emulates demote-to-helper semantics for discard instructions. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.cc index c8aee484e..3b16df793 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.cc @@ -37,6 +37,7 @@ #include "src/tint/lang/core/ir/user_call.h" #include "src/tint/lang/core/ir/validator.h" #include "src/tint/lang/core/ir/var.h" +#include "src/tint/lang/core/type/external_texture.h" #include "src/tint/utils/containers/reverse.h" using namespace tint::core::fluent_types; // NOLINT @@ -97,8 +98,30 @@ struct IndexAccess { bool operator!=(const IndexAccess&) const { return false; } }; -/// An access operation. Either a MemberAccess or IndexAccess. -using AccessOp = std::variant; +/// BufferViewAccess is an access operator for a bufferView or bufferArrayView builtin call. +/// The arguments are passed by parameter. +struct BufferViewAccess { + /// The type of call + BuiltinFn fn; + /// The result type + const core::type::Type* type; + /// Whether the length is encoded in the call + bool has_length = false; + + /// @return a hash value for this object + tint::HashCode HashCode() const { return Hash(static_cast(fn), type, has_length); } + + /// Inequality operator + bool operator!=(const BufferViewAccess& other) const { + return fn != other.fn || type != other.type || has_length != other.has_length; + } +}; + +/// An access operation. One of: +/// * MemberAccess +/// * IndexAccess +/// * BufferViewAccess +using AccessOp = std::variant; /// A AccessShape describes the static "path" from a root variable to an element within the /// variable. @@ -122,6 +145,13 @@ using AccessOp = std::variant; /// y : array /// }; /// var C : B; +/// var D : buffer<128>; +/// +/// fn foo() { +/// let d1 = bufferView>(&D, o1); +/// d1[0] = 1u; +/// let d2 = bufferArrayView>(&D, o2, s); +/// d2[1].y = 2u; /// ``` /// /// The following AccessShape would describe the following: @@ -146,6 +176,20 @@ using AccessOp = std::variant; /// | [ Var 'C', MemberAccess 'y', | u32 | C.y[indices[0]].y | /// | IndexAccess, MemberAccess 'y' ] | | | /// +------------------------------------+---------------+---------------------------------+ +/// | [ Var 'D', | u32 | bufferView>( | +/// | BufferViewAccess | | &D, | +/// | 'kBufferView' | | view_offset, | +/// | 'ptr' | | view_length). | +/// | 'true', | | [indices[0]] | +/// | IndexAccess ] | | | +/// +------------------------------------+---------------+---------------------------------+ +/// | [ Var 'D', | u32 | bufferArrayView>( | +/// | BufferViewAccess | | &D, | +/// | 'kBufferArrayView' | | view_offset, | +/// | 'ptr' | | view_size, | +/// | 'true', | | view_length). | +/// | IndexAccess ] | | [indices[0]].[indices[1]] | +/// +------------------------------------+---------------+---------------------------------+ /// /// Where: `indices` is the AccessChain::indices. struct AccessShape { @@ -182,6 +226,14 @@ struct AccessChain { Value* root_ptr = nullptr; /// The array of dynamic indices Vector indices; + /// Buffer view arguments. Only a single buffer view will be encountered along any chain (always + /// first). + /// The offset of bufferView or bufferArrayView + Value* view_offset = nullptr; + /// The size of bufferArrayView + Value* view_size = nullptr; + /// The length of bufferView or bufferArrayView + Value* view_length = nullptr; }; /// A variant signature describes the access shape of all the function's pointer parameters. @@ -309,7 +361,7 @@ struct State { VariantSignature signature; // For each argument / parameter... - for (size_t i = 0, n = call->Args().Length(); i < n; i++) { + for (size_t i = 0, n = call->Args().size(); i < n; i++) { auto* arg = call->Args()[i]; auto* param = target->Params()[i]; @@ -336,6 +388,23 @@ struct State { if (std::holds_alternative(chain.shape.root)) { new_args.Push(chain.root_ptr); } + // The bufferView/bufferArrayView must be the first op. + if (!chain.shape.ops.IsEmpty() && + std::holds_alternative(chain.shape.ops[0])) { + uint32_t count = + 1 + (chain.view_size ? 1 : 0) + (chain.view_length ? 1 : 0); + auto* array = ty.array(ty.u32(), count); + Vector args; + args.Push(chain.view_offset); + if (chain.view_size) { + args.Push(chain.view_size); + } + if (chain.view_length) { + args.Push(chain.view_length); + } + auto* values = b.Construct(array, std::move(args)); + new_args.Push(values->Result()); + } // If the chain access contains indices, then pass these as an array of u32. if (size_t array_len = chain.indices.Length(); array_len > 0) { auto* array = ty.array(ty.u32(), static_cast(array_len)); @@ -458,6 +527,37 @@ struct State { TINT_IR_ASSERT(ir, obj_ty == access->Result()->Type()->UnwrapPtr()); return access->Object(); }, + [&](CoreBuiltinCall* call) { + switch (call->Func()) { + case BuiltinFn::kBufferView: + case BuiltinFn::kBufferArrayView: { + BufferViewAccess access{.fn = call->Func(), + .type = call->Result()->Type()}; + chain.view_offset = + b.InsertConvertIfNeeded(ty.u32(), call->Args()[1]); + if (call->Func() == BuiltinFn::kBufferView) { + chain.view_length = + call->Args().size() > 2 + ? b.InsertConvertIfNeeded(ty.u32(), call->Args()[2]) + : nullptr; + } else { + chain.view_size = call->Args()[2]; + chain.view_length = + call->Args().size() > 3 + ? b.InsertConvertIfNeeded(ty.u32(), call->Args()[3]) + : nullptr; + } + if (chain.view_length) { + access.has_length = true; + } + chain.shape.ops.Push(access); + return call->Args()[0]; + } + default: + TINT_UNREACHABLE() + << "unhandle builtin call" << call->FriendlyName(); + } + }, [&](Load* load) { return load->From(); }, // [&](Var* var) { // A 'var' is a pointer root. @@ -531,6 +631,17 @@ struct State { TINT_IR_ICE(ir) << "unhandled AccessShape root variant"; } + // Build the view args parameter, if required. + ir::FunctionParam* args_param = nullptr; + if (!shape->ops.IsEmpty() && + std::holds_alternative(shape->ops[0])) { + auto* view = std::get_if(&shape->ops[0]); + uint32_t n = + (view->fn == BuiltinFn::kBufferView ? 1 : 2) + (view->has_length ? 1 : 0); + args_param = b.FunctionParam(ty.array(ty.u32(), n)); + new_params.Push(args_param); + } + // Build the access indices parameter, if required. ir::FunctionParam* indices_param = nullptr; if (uint32_t n = shape->NumIndexAccesses(); n > 0) { @@ -545,6 +656,9 @@ struct State { if (root_ptr_param) { ir.SetName(root_ptr_param, param_name.Name() + "_root"); } + if (args_param) { + ir.SetName(args_param, param_name.Name() + "_view_args"); + } if (indices_param) { ir.SetName(indices_param, param_name.Name() + "_indices"); } @@ -564,8 +678,38 @@ struct State { } // Rebuild the pointer from the root pointer and accesses. + bool has_view = false; uint32_t index_index = 0; auto chain = Transform(shape->ops, [&](const AccessOp& op) -> Value* { + if (auto* v = std::get_if(&op)) { + has_view = true; + Value* offset = b.Access(ty.u32(), args_param, 0_u)->Result(); + Value* size = nullptr; + Value* length = nullptr; + if (v->fn == BuiltinFn::kBufferArrayView) { + size = b.Access(ty.u32(), args_param, 1_u)->Result(); + } + if (v->has_length) { + length = b.Access(ty.u32(), args_param, + (v->fn == BuiltinFn::kBufferView ? 1_u : 2_u)) + ->Result(); + } + auto* call = b.CallExplicit( + v->type, v->fn, Vector{v->type->UnwrapPtr()}, + replacement); + call->AppendArg(offset); + if (size) { + call->AppendArg(size); + } + if (length) { + call->AppendArg(length); + } + root_ptr = call->Result(); + if (shape->ops.Length() == 1) { + replacement = root_ptr; + } + return root_ptr; + } if (auto* m = std::get_if(&op)) { return b.Constant(u32(m->member->Index())); } @@ -573,7 +717,15 @@ struct State { return access->Result(); }); - replacement = b.Access(access_type, root_ptr, std::move(chain))->Result(); + if (has_view) { + if (chain.Length() > 1) { + replacement = b.Access(access_type, root_ptr, + ToVector<8>(chain.AsSpan().subspan(1))) + ->Result(); + } + } else { + replacement = b.Access(access_type, root_ptr, std::move(chain))->Result(); + } } // Replaced handles need the final load after the access chain. @@ -608,6 +760,17 @@ struct State { } } + bool TransformHandle(const type::Type* param) const { + if (!param->IsHandle()) { + return false; + } + if (options.transform_handle == HandleTransformLevel::kFull) { + return true; + } + return options.transform_handle == HandleTransformLevel::kExternal && + param->Is(); + } + /// @return true if @p param is a parameter that requires transforming, based on the /// transform options. /// @param param the function parameter @@ -631,12 +794,7 @@ struct State { break; } } - - if (param_type->IsHandle()) { - return options.transform_handle; - } - - return false; + return TransformHandle(param_type); } /// Walks the instructions that built @p value, deleting those that are no longer used. @@ -658,8 +816,12 @@ struct State { TINT_DEFER(let->Destroy()); return let->Value(); }, + [&](CoreBuiltinCall* call) { + TINT_DEFER(call->Destroy()); + return call->Args()[0]; + }, [&](Load* load) { - if (options.transform_handle) { + if (TransformHandle(load->From()->Type()->UnwrapPtr())) { TINT_DEFER(load->Destroy()); return load->From(); } @@ -672,8 +834,8 @@ struct State { } // namespace Result DirectVariableAccess(Module& ir, const DirectVariableAccessOptions& options) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kDirectVariableAccessCapabilities, "core.DirectVariableAccess")); + core::ir::AssertValid(ir, kDirectVariableAccessCapabilities, + "before core.DirectVariableAccess"); State{ir, options}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.h index 1e95d4187..dea23fccf 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/direct_variable_access.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_DIRECT_VARIABLE_ACCESS_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -41,20 +41,45 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kDirectVariableAccessCapabilities{ - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, }; +/// The level of handle workspace change +enum class HandleTransformLevel { + kNone, + kExternal, + kFull, +}; + +/// @param out the stream to write to +/// @param level the transform level +/// @returns @p out so calls can be chained +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, HandleTransformLevel level) { + switch (level) { + case HandleTransformLevel::kNone: + out << "none"; + break; + case HandleTransformLevel::kExternal: + out << "external"; + break; + case HandleTransformLevel::kFull: + out << "full"; + break; + } + return out; +} + /// DirectVariableAccessOptions adjusts the behaviour of the transform. struct DirectVariableAccessOptions { /// If true, then 'private' sub-object pointer arguments will be transformed. bool transform_private = false; /// If true, then 'function' sub-object pointer arguments will be transformed. bool transform_function = false; - /// If true, then 'handle' sub-object handle type arguments will be transformed. - bool transform_handle = false; + /// If `kExternal` the external textures are transformed, if `kFull` then all 'handle' + /// sub-object handle type arguments will be transformed. + HandleTransformLevel transform_handle = HandleTransformLevel::kNone; /// Reflection for this class TINT_REFLECT(DirectVariableAccessOptions, @@ -82,4 +107,8 @@ Result DirectVariableAccess(Module& module, } // namespace tint::core::ir::transform +namespace tint { +TINT_REFLECT_ENUM_RANGE(tint::core::ir::transform::HandleTransformLevel, kNone, kFull); +} + #endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_DIRECT_VARIABLE_ACCESS_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc index 69a759260..590e12387 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.cc @@ -41,6 +41,13 @@ using namespace tint::core::number_suffixes; // NOLINT namespace tint::core::ir::transform { namespace { +template +struct overloaded : Ts... { + using Ts::operator()...; +}; + +using MultiplanarTexture = tint::transform::multiplanar::MultiplanarTexture; +using YCBCRTexture = tint::transform::multiplanar::YCBCRTexture; /// PIMPL state for the transform. struct State { @@ -59,20 +66,30 @@ struct State { /// The symbol table. SymbolTable& sym{ir.symbols}; - /// The gamma transfer parameters structure. - const core::type::Struct* gamma_transfer_params_struct = nullptr; + /// The transfer function parameters structure. + const core::type::Struct* transfer_function_params_struct = nullptr; /// The external texture parameters structure. const core::type::Struct* external_texture_params_struct = nullptr; /// The helper function that implements `textureLoad()`. - Function* texture_load_external = nullptr; + Function* texture_load_multiplanar_external = nullptr; + Function* texture_load_ycbcr_external = nullptr; /// The helper function that implements `textureSampleBaseClampToEdge()`. - Function* texture_sample_external = nullptr; + Function* texture_sample_clamp_to_edge_multiplanar_external = nullptr; + Function* texture_sample_clamp_to_edge_ycbcr_external = nullptr; - /// The gamma correction helper function. - Function* gamma_correction = nullptr; + /// The transfer function application helper functions. + Function* apply_src_transfer_function = nullptr; + Function* apply_gamma_transfer_function = nullptr; + Function* apply_hlg_transfer_function = nullptr; + Function* apply_pq_transfer_function = nullptr; + + enum class UsedAs : uint8_t { + kMultiplanar, + kYcbcr, + }; /// Process the module. Result Process() { @@ -125,16 +142,45 @@ struct State { err << "ExternalTextureOptions missing binding entry for " << bp.value(); return Failure{err.str()}; } - const auto& new_binding_points = itr->second; - // Create a sampled texture for the first plane. - auto* plane_0 = b.Var(ty.ptr(handle, SampledTexture())); - plane_0->SetBindingPoint(bp->group, bp->binding); - plane_0->InsertBefore(old_var); + // Create a uniform buffer for the external texture parameters. The binding point is set in + // the specific type in the replace calls below. + auto* external_texture_params = b.Var(ty.ptr(uniform, ExternalTextureParams())); + external_texture_params->InsertBefore(old_var); + if (name) { + ir.SetName(external_texture_params, name.Name() + "_params"); + } + + // Create a sampled texture for texture. The name is set inside the specific calls below + auto* texture = b.Var(ty.ptr(handle, SampledTexture())); + texture->SetBindingPoint(bp->group, bp->binding); + texture->InsertBefore(old_var); + + std::visit(overloaded{[&](const MultiplanarTexture& m) { + ReplaceMultiplanarVar(old_var, name, m, texture, + external_texture_params); + }, + [&](const YCBCRTexture& t) { + ReplaceYCBCRVar(old_var, name, t, texture, + external_texture_params); + }}, + itr->second); + + return Success; + } + + void ReplaceMultiplanarVar(Var* old_var, + Symbol name, + const MultiplanarTexture& new_binding_points, + Var* plane_0, + Var* external_texture_params) { if (name) { ir.SetName(plane_0, name.Name() + "_plane0"); } + external_texture_params->SetBindingPoint(new_binding_points.params.group, + new_binding_points.params.binding); + // Create a sampled texture for the second plane. auto* plane_1 = b.Var(ty.ptr(handle, SampledTexture())); plane_1->SetBindingPoint(new_binding_points.plane_1.group, @@ -144,20 +190,34 @@ struct State { ir.SetName(plane_1, name.Name() + "_plane1"); } - // Create a uniform buffer for the external texture parameters. - auto* external_texture_params = b.Var(ty.ptr(uniform, ExternalTextureParams())); + // Replace all uses of the old variable with the new ones. + ReplaceUses(UsedAs::kMultiplanar, old_var->Result(), plane_0->Result(), plane_1->Result(), + external_texture_params->Result()); + } + void ReplaceYCBCRVar(Var* old_var, + Symbol name, + const YCBCRTexture& new_binding_points, + Var* texture, + Var* external_texture_params) { + if (name) { + ir.SetName(texture, name.Name()); + } + external_texture_params->SetBindingPoint(new_binding_points.params.group, new_binding_points.params.binding); - external_texture_params->InsertBefore(old_var); + + // Create a sampler + auto* sampler = b.Var(ty.ptr(handle, ty.sampler())); + sampler->SetBindingPoint(new_binding_points.sampler.group, + new_binding_points.sampler.binding); + sampler->InsertBefore(old_var); if (name) { - ir.SetName(external_texture_params, name.Name() + "_params"); + ir.SetName(sampler, name.Name() + "_ycbcr_sampler"); } // Replace all uses of the old variable with the new ones. - ReplaceUses(old_var->Result(), plane_0->Result(), plane_1->Result(), + ReplaceUses(UsedAs::kYcbcr, old_var->Result(), texture->Result(), sampler->Result(), external_texture_params->Result()); - - return Success; } /// Replace an external texture function parameter. @@ -198,29 +258,31 @@ struct State { func->SetParams(std::move(new_params)); // Replace all uses of the old parameter with the new ones. - ReplaceUses(old_param, plane_0, plane_1, external_texture_params); + ReplaceUses(UsedAs::kMultiplanar, old_param, plane_0, plane_1, external_texture_params); } /// Recursively replace the uses of @p value with @p new_value. + /// @param used_as how the parameter is used /// @param old_value the external texture value whose usages should be replaced - /// @param plane_0 the first plane of the replacement texture - /// @param plane_1 the second plane of the replacement texture + /// @param first the first parameter of the replacement, a texture + /// @param second the second parameter of the replacement, a texture or a sampler /// @param params the parameters of the replacement texture - void ReplaceUses(Value* old_value, Value* plane_0, Value* plane_1, Value* params) { + void ReplaceUses(UsedAs used_as, Value* old_value, Value* first, Value* second, Value* params) { old_value->ForEachUseUnsorted([&](Usage use) { tint::Switch( use.instruction, [&](Load* load) { // Load both of the planes and the parameters struct. - Value* plane_0_load = nullptr; - Value* plane_1_load = nullptr; - Value* params_load = nullptr; + Value* et_first_load = nullptr; + Value* et_second_load = nullptr; + Value* et_params_load = nullptr; b.InsertBefore(load, [&] { - plane_0_load = b.Load(plane_0)->Result(); - plane_1_load = b.Load(plane_1)->Result(); - params_load = b.Load(params)->Result(); + et_first_load = b.Load(first)->Result(); + et_second_load = b.Load(second)->Result(); + et_params_load = b.Load(params)->Result(); }); - ReplaceUses(load->Result(), plane_0_load, plane_1_load, params_load); + ReplaceUses(used_as, load->Result(), et_first_load, et_second_load, + et_params_load); load->Destroy(); }, [&](CoreBuiltinCall* call) { @@ -243,17 +305,33 @@ struct State { } // Call the `TextureLoadExternal()` helper function. - auto* helper = b.CallWithResult(call->DetachResult(), TextureLoadExternal(), - plane_0, plane_1, params, coords); + Call* helper = nullptr; + if (used_as == UsedAs::kMultiplanar) { + Function* func = TextureLoadMultiplanarExternal(); + helper = b.CallWithResult(call->DetachResult(), func, first, second, + params, coords); + } else { + Function* func = TextureLoadYCBCRExternal(); + helper = + b.CallWithResult(call->DetachResult(), func, first, params, coords); + } helper->InsertBefore(call); call->Destroy(); } else if (call->Func() == core::BuiltinFn::kTextureSampleBaseClampToEdge) { - // Call the `TextureSampleExternal()` helper function. + // Call the `TextureSampleClampToEdgeMultiplanarExternal()` helper function. auto* sampler = call->Args()[1]; auto* coords = call->Args()[2]; - auto* helper = - b.CallWithResult(call->DetachResult(), TextureSampleExternal(), plane_0, - plane_1, params, sampler, coords); + + Call* helper = nullptr; + if (used_as == UsedAs::kMultiplanar) { + Function* func = TextureSampleClampToEdgeMultiplanarExternal(); + helper = b.CallWithResult(call->DetachResult(), func, first, second, + params, sampler, coords); + } else { + Function* func = TextureSampleClampToEdgeYCBCRExternal(); + helper = b.CallWithResult(call->DetachResult(), func, first, second, + params, coords); + } helper->InsertBefore(call); call->Destroy(); } else { @@ -262,12 +340,14 @@ struct State { } }, [&](UserCall* call) { + TINT_ASSERT(used_as != UsedAs::kYcbcr); + // Decompose the external texture operand into both planes and the parameters. Vector operands; for (uint32_t i = 0; i < call->Operands().Length(); i++) { if (i == use.operand_index) { - operands.Push(plane_0); - operands.Push(plane_1); + operands.Push(first); + operands.Push(second); operands.Push(params); } else { operands.Push(call->Operands()[i]); @@ -279,22 +359,22 @@ struct State { }); } - /// @returns the gamma transfer parameters struct - const core::type::Struct* GammaTransferParams() { - if (!gamma_transfer_params_struct) { - gamma_transfer_params_struct = ty.Struct(sym.Register("tint_GammaTransferParams"), - { - {sym.Register("G"), ty.f32()}, - {sym.Register("A"), ty.f32()}, - {sym.Register("B"), ty.f32()}, - {sym.Register("C"), ty.f32()}, - {sym.Register("D"), ty.f32()}, - {sym.Register("E"), ty.f32()}, - {sym.Register("F"), ty.f32()}, - {sym.Register("padding"), ty.u32()}, - }); + /// @returns the transfer function parameters struct + const core::type::Struct* TransferFunctionParams() { + if (!transfer_function_params_struct) { + transfer_function_params_struct = ty.Struct(sym.Register("tint_TransferFunctionParams"), + { + {sym.Register("mode"), ty.u32()}, + {sym.Register("A"), ty.f32()}, + {sym.Register("B"), ty.f32()}, + {sym.Register("C"), ty.f32()}, + {sym.Register("D"), ty.f32()}, + {sym.Register("E"), ty.f32()}, + {sym.Register("F"), ty.f32()}, + {sym.Register("G"), ty.f32()}, + }); } - return gamma_transfer_params_struct; + return transfer_function_params_struct; } /// @returns the external textures parameters struct @@ -302,33 +382,37 @@ struct State { if (!external_texture_params_struct) { external_texture_params_struct = ty.Struct(sym.Register("tint_ExternalTextureParams"), - {{sym.Register("numPlanes"), ty.u32()}, - {sym.Register("doYuvToRgbConversionOnly"), ty.u32()}, - {sym.Register("yuvToRgbConversionMatrix"), ty.mat3x4()}, - {sym.Register("gammaDecodeParams"), GammaTransferParams()}, - {sym.Register("gammaEncodeParams"), GammaTransferParams()}, - {sym.Register("gamutConversionMatrix"), ty.mat3x3()}, - {sym.Register("sampleTransform"), ty.mat3x2()}, - {sym.Register("loadTransform"), ty.mat3x2()}, - {sym.Register("samplePlane0RectMin"), ty.vec2f()}, - {sym.Register("samplePlane0RectMax"), ty.vec2f()}, - {sym.Register("samplePlane1RectMin"), ty.vec2f()}, - {sym.Register("samplePlane1RectMax"), ty.vec2f()}, - {sym.Register("apparentSize"), ty.vec2u()}, - {sym.Register("plane1CoordFactor"), ty.vec2f()}}); + { + {sym.Register("numPlanes"), ty.u32()}, + {sym.Register("doYuvToRgbConversionOnly"), ty.u32()}, + {sym.Register("yuvToRgbConversionMatrix"), ty.mat3x4()}, + {sym.Register("srcTransferFunction"), TransferFunctionParams()}, + {sym.Register("dstTransferFunction"), TransferFunctionParams()}, + {sym.Register("gamutConversionMatrix"), ty.mat3x3()}, + {sym.Register("sampleTransform"), ty.mat3x2()}, + {sym.Register("loadTransform"), ty.mat3x2()}, + {sym.Register("samplePlane0RectMin"), ty.vec2f()}, + {sym.Register("samplePlane0RectMax"), ty.vec2f()}, + {sym.Register("samplePlane1RectMin"), ty.vec2f()}, + {sym.Register("samplePlane1RectMax"), ty.vec2f()}, + {sym.Register("apparentSize"), ty.vec2u()}, + {sym.Register("plane1CoordFactor"), ty.vec2f()}, + {sym.Register("ootfParam"), ty.vec4f()}, + }); } return external_texture_params_struct; } - /// Gets or creates the gamma correction helper function. + /// Gets or creates the gamma transfer function application helper function. /// @returns the function - Function* GammaCorrection() { - if (gamma_correction) { - return gamma_correction; + Function* ApplyGammaTransferFunction() { + if (apply_gamma_transfer_function) { + return apply_gamma_transfer_function; } // The helper function implements the following: - // fn tint_GammaCorrection(v : vec3f, params : GammaTransferParams) -> vec3f { + // fn tint_ApplyGammaTransferFunction(v : vec3f, params : TransferFunctionParams) -> vec3f + // { // let abs_v = abs(v); // let sign_v = sign(v); // let cond = abs_v < vec3f(params.D); @@ -336,19 +420,28 @@ struct State { // let f = sign_v * (pow((params.A * abs_v) + params.B, vec3f(params.G)) + params.E); // return select(f, t, cond); // } - gamma_correction = b.Function("tint_GammaCorrection", ty.vec3f()); + apply_gamma_transfer_function = b.Function("tint_ApplyGammaTransferFunction", ty.vec3f()); auto* v = b.FunctionParam("v", ty.vec3f()); - auto* params = b.FunctionParam("params", GammaTransferParams()); - gamma_correction->SetParams({v, params}); - b.Append(gamma_correction->Block(), [&] { + auto* params = b.FunctionParam("params", TransferFunctionParams()); + apply_gamma_transfer_function->SetParams({v, params}); + b.Append(apply_gamma_transfer_function->Block(), [&] { auto* vec3f = ty.vec3f(); - auto* G = b.Access(ty.f32(), params, 0_u); auto* A = b.Access(ty.f32(), params, 1_u); auto* B = b.Access(ty.f32(), params, 2_u); auto* C = b.Access(ty.f32(), params, 3_u); auto* D = b.Access(ty.f32(), params, 4_u); auto* E = b.Access(ty.f32(), params, 5_u); auto* F = b.Access(ty.f32(), params, 6_u); + auto* G = b.Access(ty.f32(), params, 7_u); + + b.Name("A", A); + b.Name("B", B); + b.Name("C", C); + b.Name("D", D); + b.Name("E", E); + b.Name("F", F); + b.Name("G", G); + auto* G_splat = b.Construct(vec3f, G); auto* D_splat = b.Construct(vec3f, D); auto* abs_v = b.Call(vec3f, core::BuiltinFn::kAbs, v); @@ -358,71 +451,335 @@ struct State { auto* f = b.Multiply(sign_v, b.Add(b.Call(vec3f, core::BuiltinFn::kPow, b.Add(b.Multiply(A, abs_v), B), G_splat), E)); - b.Return(gamma_correction, b.Call(vec3f, core::BuiltinFn::kSelect, f, t, cond)); + b.Return(apply_gamma_transfer_function, + b.Call(vec3f, core::BuiltinFn::kSelect, f, t, cond)); }); - return gamma_correction; + return apply_gamma_transfer_function; } - /// Gets or creates the texture load helper function. + /// Gets or creates the hlg transfer function application helper function. /// @returns the function - Function* TextureLoadExternal() { - if (texture_load_external) { - return texture_load_external; + /// Reference: + /// * https://www.khronos.org/registry/DataFormat/specs/1.3/dataformat.1.3.inline.html#TRANSFER_HLG + /// * Specifically HLG OETF^-1 (normalized) + Function* ApplyHLGTransferFunction() { + if (apply_hlg_transfer_function) { + return apply_hlg_transfer_function; } // The helper function implements the following: - // fn tint_TextureLoadExternal(plane0 : texture_2d, - // plane1 : texture_2d, - // coords : vec2, - // params : ExternalTextureParams) ->vec4f { - // let clampedCoords = min(coords, params.apparentSize); - // let plane0_clamped = vec2( - // round(params.loadTransform * vec3(vec2(clampedCoords), 1))); - // var color : vec4; - // if ((params.numPlanes == 1)) { - // color = textureLoad(plane0, plane0_clamped, 0).rgba; + // note: cutoff = params.D + // lower_scale = params.E + // upper_scale = params.F + + // fn tint_ApplyHLGSingleChannel(v : f32, params: TransferFunctionParams -> f32 { + // if (c <= params.cutoff) { + // return (v * v) / params.lower_scale // } else { - // let plane1_clamped = vec2(plane0_clamped) * params.plane1CoordFactor; + // return (params.B + exp((v - params.C) / params.A)) / params.upper_scale; + // } + // unreachable(); + // } // - // color = vec4((vec4(textureLoad(plane0, plane0_clamped, 0).r, + // fn tint_ApplyHLGTransferFunction(v : vec3f, params : TransferFunctionParams) -> vec3f { + // let r = tintApplyHLGSingleChannel(v.r, params); + // let g = tintApplyHLGSingleChannel(v.g, params); + // let b = tintApplyHLGSingleChannel(v.b, params); + // return vec3f(r, g, b); + // } + + Function* apply_hlg_single_channel = nullptr; + { + apply_hlg_single_channel = b.Function("tint_ApplyHLGSingleChannel", ty.f32()); + auto* v = b.FunctionParam("v", ty.f32()); + auto* params = b.FunctionParam("params", TransferFunctionParams()); + apply_hlg_single_channel->SetParams({v, params}); + b.Append(apply_hlg_single_channel->Block(), [&] { + auto* A = b.Access(ty.f32(), params, 1_u); + auto* B = b.Access(ty.f32(), params, 2_u); + auto* C = b.Access(ty.f32(), params, 3_u); + auto* cutoff = b.Access(ty.f32(), params, 4_u); + auto* lower_scale = b.Access(ty.f32(), params, 5_u); + auto* upper_scale = b.Access(ty.f32(), params, 6_u); + + b.Name("A", A); + b.Name("B", B); + b.Name("C", C); + b.Name("cutoff", cutoff); + b.Name("lower_scale", lower_scale); + b.Name("upper_scale", upper_scale); + + auto* if_ = b.If(b.LessThanEqual(v, cutoff)); + b.Append(if_->True(), [&] { + auto* vv = b.Multiply(v, v); + b.Return(apply_hlg_single_channel, b.Divide(vv, lower_scale)); + }); + b.Append(if_->False(), [&] { + auto* exp = + b.Call(ty.f32(), core::BuiltinFn::kExp, b.Divide(b.Subtract(v, C), A)); + auto* num = b.Add(B, exp); + b.Return(apply_hlg_single_channel, b.Divide(num, upper_scale)); + }); + b.Unreachable(); + }); + } + + { + apply_hlg_transfer_function = b.Function("tint_ApplyHLGTransferFunction", ty.vec3f()); + auto* v = b.FunctionParam("v", ty.vec3f()); + auto* params = b.FunctionParam("params", TransferFunctionParams()); + apply_hlg_transfer_function->SetParams({v, params}); + b.Append(apply_hlg_transfer_function->Block(), [&] { + auto* red = b.Call(ty.f32(), apply_hlg_single_channel, + b.Swizzle(ty.f32(), v, {0_u}), params); + auto* green = b.Call(ty.f32(), apply_hlg_single_channel, + b.Swizzle(ty.f32(), v, {1_u}), params); + auto* blue = b.Call(ty.f32(), apply_hlg_single_channel, + b.Swizzle(ty.f32(), v, {2_u}), params); + + b.Return(apply_hlg_transfer_function, b.Construct(ty.vec3f(), red, green, blue)); + }); + } + + return apply_hlg_transfer_function; + } + + /// Gets or creates the pq transfer function application helper function. + /// @returns the function + // Reference: + // * https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.inline.html#TRANSFER_PQ + // * Specifically the PQ EOTF + Function* ApplyPQTransferFunction() { + if (apply_pq_transfer_function) { + return apply_pq_transfer_function; + } + + // + // The helper function implements the following: + // note: m1 = params.A + // m2 = params.B + // c1 = params.C + // c2 = params.D + // c3 = params.E + // fn tint_ApplyPQTransferFunction(v : vec3f, params : TransferFunctionParams) -> vec3f { + // let clamped = clamp(v, vec3f(0), vec3f(1)); + // let pow = pow(clamped, 1.f / vec3f(m2)); + // let num = max(pow - c1, 0.f); + // let denom = c2 - (c3 * pow); + // let res = num / denom + // return pow(res, 1.f / vec3f(m1)); + // } + apply_pq_transfer_function = b.Function("tint_ApplyPQTransferFunction", ty.vec3f()); + auto* v = b.FunctionParam("v", ty.vec3f()); + auto* params = b.FunctionParam("params", TransferFunctionParams()); + apply_pq_transfer_function->SetParams({v, params}); + b.Append(apply_pq_transfer_function->Block(), [&] { + auto* m1 = b.Access(ty.f32(), params, 1_u); + auto* m2 = b.Access(ty.f32(), params, 2_u); + auto* c1 = b.Access(ty.f32(), params, 3_u); + auto* c2 = b.Access(ty.f32(), params, 4_u); + auto* c3 = b.Access(ty.f32(), params, 5_u); + + b.Name("m1", m1); + b.Name("m2", m2); + b.Name("c1", c1); + b.Name("c2", c2); + b.Name("c3", c3); + + auto* c1_splat = b.Construct(ty.vec3f(), c1); + auto* c2_splat = b.Construct(ty.vec3f(), c2); + auto* c3_splat = b.Construct(ty.vec3f(), c3); + auto* m1_splat = b.Construct(ty.vec3f(), m1); + auto* m2_splat = b.Construct(ty.vec3f(), m2); + + auto* one = b.Splat(ty.vec3f(), 1_f); + auto* zero = b.Splat(ty.vec3f(), 0_f); + + auto* clamped = b.Call(ty.vec3f(), core::BuiltinFn::kClamp, v, zero, one); + auto* pow = b.Call(ty.vec3f(), core::BuiltinFn::kPow, clamped, b.Divide(one, m2_splat)); + auto* num = b.Call(ty.vec3f(), core::BuiltinFn::kMax, b.Subtract(pow, c1_splat), zero); + auto* denom = b.Subtract(c2_splat, b.Multiply(c3_splat, pow)); + auto* res = b.Divide(num, denom); + b.Return(apply_pq_transfer_function, + b.Call(ty.vec3f(), core::BuiltinFn::kPow, res, b.Divide(one, m1_splat))); + }); + + return apply_pq_transfer_function; + } + + // The src transfer function is based on the mode param + Function* ApplySrcTransferFunction() { + if (apply_src_transfer_function) { + return apply_src_transfer_function; + } + + // The helper function implements the following: + // fn tint_ApplySrcTransferFunction(v : vec3f, params : TransferFunctionParams) -> vec3f { + // let mode = params.mode; + // if (mode == 0) { + // return ApplyGammaTransferFunction(v, params); + // } else { + // if (mode == 1) { + // return ApplyHLGTransferFunction(v, params); + // } else { + // return ApplyPQTransferFunction(v, params); + // } + // unreachable(); + // } + // unreachable(); + // } + + apply_src_transfer_function = b.Function("tint_ApplySrcTransferFunction", ty.vec3f()); + auto* v = b.FunctionParam("v", ty.vec3f()); + auto* params = b.FunctionParam("params", TransferFunctionParams()); + apply_src_transfer_function->SetParams({v, params}); + b.Append(apply_src_transfer_function->Block(), [&] { + auto* mode = b.Access(ty.u32(), params, 0_u); + b.Name("mode", mode); + + auto* outer_if = b.If(b.Equal(mode, 0_u)); + b.Append(outer_if->True(), [&] { + b.Return(apply_src_transfer_function, + b.Call(ty.vec3f(), ApplyGammaTransferFunction(), v, params)); + }); + b.Append(outer_if->False(), [&] { + auto* inner_if = b.If(b.Equal(mode, 1_u)); + b.Append(inner_if->True(), [&] { + b.Return(apply_src_transfer_function, + b.Call(ty.vec3f(), ApplyHLGTransferFunction(), v, params)); + }); + + b.Append(inner_if->False(), [&] { + b.Return(apply_src_transfer_function, + b.Call(ty.vec3f(), ApplyPQTransferFunction(), v, params)); + }); + b.Unreachable(); + }); + b.Unreachable(); + }); + + return apply_src_transfer_function; + } + + // The destination transfer is always gamma + Function* ApplyDstTransferFunction() { return ApplyGammaTransferFunction(); } + + // if ((params.doYuvToRgbConversionOnly == 0)) { + // color = applyTransferFunction(color.rgb, params.srcTransferFunction); + // color = (params.gamutConversionMatrix * color.rgb); + // color = applyTransferFunction(color.rgb, params.dstTransferFunction); + // if (ootf.w != 0) { + // let y: f32 = dot(ootf.rgb, decoded); + // let a: f32 = abs(y); + // let p: f32 = pow(a, ootf.w); + // let s: f32 = sign(y); + // let exp: f32 = s * p; + // color *= s; + // } + // } + ir::Value* ApplyGammaCorrect(ir::Value* params, ir::Value* rgb_result) { + auto* yuv_to_rgb_conversion_only = b.Access(ty.u32(), params, 1_u); + + auto* final_result = b.InstructionResult(ty.vec3f()); + auto* if_gamma_correct = b.If(b.Equal(yuv_to_rgb_conversion_only, 0_u)); + if_gamma_correct->SetResult(final_result); + b.Append(if_gamma_correct->True(), [&] { + auto* src_transfer_function = b.Access(TransferFunctionParams(), params, 3_u); + auto* dst_transfer_function = b.Access(TransferFunctionParams(), params, 4_u); + auto* gamut_conversion_matrix = b.Access(ty.mat3x3(), params, 5_u); + auto* ootf = b.Access(ty.vec4f(), params, 14_u); + + auto* decoded = + b.Call(ty.vec3f(), ApplySrcTransferFunction(), rgb_result, src_transfer_function); + + auto* ootf_arg_w = b.Swizzle(ty.f32(), ootf, {3_u}); + auto* cmp = b.NotEqual(ootf_arg_w, 0_f); + + auto* ootf_res = b.InstructionResult(ty.vec3f()); + auto* apply_ootf = b.If(cmp); + apply_ootf->SetResult(ootf_res); + + b.Append(apply_ootf->True(), [&] { + auto* rgb = b.Swizzle(ty.vec3f(), ootf, {0_u, 1_u, 2_u}); + auto* y = b.Call(ty.f32(), BuiltinFn::kDot, rgb, decoded); + auto* a = b.Call(ty.f32(), BuiltinFn::kAbs, y); + auto* p = b.Call(ty.f32(), BuiltinFn::kPow, a, ootf_arg_w); + auto* s = b.Call(ty.f32(), BuiltinFn::kSign, y); + auto* exp = b.Multiply(s, p); + auto* res = b.Multiply(decoded, exp); + b.ExitIf(apply_ootf, res); + }); + b.Append(apply_ootf->False(), [&] { b.ExitIf(apply_ootf, decoded); }); + + auto* converted = b.Multiply(gamut_conversion_matrix, ootf_res); + auto* encoded = + b.Call(ty.vec3f(), ApplyDstTransferFunction(), converted, dst_transfer_function); + b.ExitIf(if_gamma_correct, encoded); + }); + b.Append(if_gamma_correct->False(), [&] { // + b.ExitIf(if_gamma_correct, rgb_result); + }); + return final_result; + } + + /// Gets or creates the multiplanar texture load helper function. + /// @returns the function + Function* TextureLoadMultiplanarExternal() { + if (texture_load_multiplanar_external) { + return texture_load_multiplanar_external; + } + + // The helper function implements the following: + // fn tint_TextureLoadMultiplanarExternal(plane0: texture_2d, + // plane1: texture_2d, + // params: ExternalTextureParams, + // coords: vec2) ->vec4f { + // let clampedCoords = min(coords, params.apparentSize); + // let loadCoords = vec2( + // round(params.loadTransform * vec3(vec2(clampedCoords), 1))); + // var color: vec3; + // var alpha: f32; + // if ((params.numPlanes == 1)) { + // let val = textureLoad(plane0, loadCoords, 0).rgba; + // color = val.xyz; + // alpha = val.w; + // } else { + // let plane1_clamped = vec2(vec2(loadCoords) * + // params.plane1CoordFactor); + // + // color = (vec4(textureLoad(plane0, loadCoords, 0).r, // textureLoad(plane1, plane1_clamped, 0).rg, 1) * - // params.yuvToRgbConversionMatrix), - // 1); + // params.yuvToRgbConversionMatrix)); + // alpha = 1.f; // } - // if ((params.doYuvToRgbConversionOnly == 0)) { - // color = vec4(gammaCorrection(color.rgb, params.gammaDecodeParams), color.a); - // color = vec4((params.gamutConversionMatrix * color.rgb), color.a); - // color = vec4(gammaCorrection(color.rgb, params.gammaEncodeParams), color.a); - // } - // return color; + // + // color = ApplyGammaCorrect(params, color) + // + // return vec4f(color, alpha); // } - texture_load_external = b.Function("tint_TextureLoadExternal", ty.vec4f()); + texture_load_multiplanar_external = + b.Function("tint_TextureLoadMultiplanarExternal", ty.vec4f()); auto* plane_0 = b.FunctionParam("plane_0", SampledTexture()); auto* plane_1 = b.FunctionParam("plane_1", SampledTexture()); auto* params = b.FunctionParam("params", ExternalTextureParams()); auto* coords = b.FunctionParam("coords", ty.vec2u()); - texture_load_external->SetParams({plane_0, plane_1, params, coords}); - b.Append(texture_load_external->Block(), [&] { - auto* vec2f = ty.vec2f(); - auto* vec3f = ty.vec3f(); - auto* vec4f = ty.vec4f(); - auto* vec2u = ty.vec2u(); - auto* yuv_to_rgb_conversion_only = b.Access(ty.u32(), params, 1_u); + texture_load_multiplanar_external->SetParams({plane_0, plane_1, params, coords}); + + b.Append(texture_load_multiplanar_external->Block(), [&] { auto* yuv_to_rgb_conversion = b.Access(ty.mat3x4(), params, 2_u); auto* load_transform_matrix = b.Access(ty.mat3x2(), params, 7_u); auto* apparent_size = b.Access(ty.vec2u(), params, 12_u); auto* plane1_coord_factor = b.Access(ty.vec2f(), params, 13_u); auto* clamped_coords = b.Min(coords, apparent_size); - auto* clamped_coords_f = b.Convert(vec2f, clamped_coords); + auto* clamped_coords_f = b.Convert(ty.vec2f(), clamped_coords); auto* modified_coords = - b.Multiply(load_transform_matrix, b.Construct(vec3f, clamped_coords_f, 1_f)); - auto* plane0_clamped_f = b.Call(vec2f, core::BuiltinFn::kRound, modified_coords); + b.Multiply(load_transform_matrix, b.Construct(ty.vec3f(), clamped_coords_f, 1_f)); + auto* loadCoords_f = b.Call(ty.vec2f(), core::BuiltinFn::kRound, modified_coords); + auto* loadCoords = b.Convert(ty.vec2u(), loadCoords_f); - auto* plane0_clamped = b.Convert(vec2u, plane0_clamped_f); - - auto* rgb_result = b.InstructionResult(vec3f); + auto* rgb_result = b.InstructionResult(ty.vec3f()); auto* alpha_result = b.InstructionResult(ty.f32()); auto* num_planes = b.Access(ty.u32(), params, 0_u); auto* if_planes_eq_1 = b.If(b.Equal(num_planes, 1_u)); @@ -430,8 +787,8 @@ struct State { b.Append(if_planes_eq_1->True(), [&] { // Load the texel from the first plane and split into separate rgb and a values. auto* texel = - b.Call(vec4f, core::BuiltinFn::kTextureLoad, plane_0, plane0_clamped, 0_u); - auto* rgb = b.Swizzle(vec3f, texel, {0u, 1u, 2u}); + b.Call(ty.vec4f(), core::BuiltinFn::kTextureLoad, plane_0, loadCoords, 0_u); + auto* rgb = b.Swizzle(ty.vec3f(), texel, {0u, 1u, 2u}); auto* a = b.Access(ty.f32(), texel, 3_u); b.ExitIf(if_planes_eq_1, rgb, a); }); @@ -439,96 +796,137 @@ struct State { // Load the y value from the first plane. auto* y = b.Access( ty.f32(), - b.Call(vec4f, core::BuiltinFn::kTextureLoad, plane_0, plane0_clamped, 0_u), + b.Call(ty.vec4f(), core::BuiltinFn::kTextureLoad, plane_0, loadCoords, 0_u), 0_u); // Load the uv value from the second plane. - auto* plane1_clamped_f = b.Multiply(plane0_clamped_f, plane1_coord_factor); + auto* plane1_clamped_f = b.Multiply(loadCoords_f, plane1_coord_factor); - auto* plane1_clamped = b.Convert(vec2u, plane1_clamped_f); + auto* plane1_clamped = b.Convert(ty.vec2u(), plane1_clamped_f); auto* uv = b.Swizzle( - vec2f, - b.Call(vec4f, core::BuiltinFn::kTextureLoad, plane_1, plane1_clamped, 0_u), + ty.vec2f(), + b.Call(ty.vec4f(), core::BuiltinFn::kTextureLoad, plane_1, plane1_clamped, 0_u), {0u, 1u}); // Convert the combined yuv value into rgb and set the alpha to 1.0. b.ExitIf(if_planes_eq_1, - b.Multiply(b.Construct(vec4f, y, uv, 1_f), yuv_to_rgb_conversion), 1_f); + b.Multiply(b.Construct(ty.vec4f(), y, uv, 1_f), yuv_to_rgb_conversion), + 1_f); }); // Apply gamma correction if needed. - auto* final_result = b.InstructionResult(vec3f); - auto* if_gamma_correct = b.If(b.Equal(yuv_to_rgb_conversion_only, 0_u)); - if_gamma_correct->SetResult(final_result); - b.Append(if_gamma_correct->True(), [&] { - auto* gamma_decode_params = b.Access(GammaTransferParams(), params, 3_u); - auto* gamma_encode_params = b.Access(GammaTransferParams(), params, 4_u); - auto* gamut_conversion_matrix = b.Access(ty.mat3x3(), params, 5_u); - auto* decoded = b.Call(vec3f, GammaCorrection(), rgb_result, gamma_decode_params); - auto* converted = b.Multiply(gamut_conversion_matrix, decoded); - auto* encoded = b.Call(vec3f, GammaCorrection(), converted, gamma_encode_params); - b.ExitIf(if_gamma_correct, encoded); - }); - b.Append(if_gamma_correct->False(), [&] { // - b.ExitIf(if_gamma_correct, rgb_result); - }); - - b.Return(texture_load_external, b.Construct(vec4f, final_result, alpha_result)); + auto* final_result = ApplyGammaCorrect(params, rgb_result); + b.Return(texture_load_multiplanar_external, + b.Construct(ty.vec4f(), final_result, alpha_result)); }); - return texture_load_external; + return texture_load_multiplanar_external; + } + + /// Gets or creates the YCBCR texture load helper function. + /// @returns the function + Function* TextureLoadYCBCRExternal() { + if (texture_load_ycbcr_external) { + return texture_load_ycbcr_external; + } + + // The helper function implements the following: + // fn tint_TextureLoadYcbcrExternal(texture: texture_2d, + // params: ExternalTextureParams, + // coords: vec2) ->vec4f { + // let clampedCoords = min(coords, params.apparentSize); + // let loadCoords = vec2( + // round(params.loadTransform * vec3(vec2(clampedCoords), 1))); + // var color = textureLoad(texture, loadCoords, 0).rgb, 1) * + // params.yuvToRgbConversionMatrix; + // + // color = ApplyGammaCorrect(params, color) + // + // return vec4f(color, 1); + // } + texture_load_ycbcr_external = b.Function("tint_TextureLoadYcbcrExternal", ty.vec4f()); + auto* texture = b.FunctionParam("texture", SampledTexture()); + auto* params = b.FunctionParam("params", ExternalTextureParams()); + auto* coords = b.FunctionParam("coords", ty.vec2u()); + texture_load_ycbcr_external->SetParams({texture, params, coords}); + + b.Append(texture_load_ycbcr_external->Block(), [&] { + auto* yuv_to_rgb_conversion = b.Access(ty.mat3x4(), params, 2_u); + auto* load_transform_matrix = b.Access(ty.mat3x2(), params, 7_u); + auto* apparent_size = b.Access(ty.vec2u(), params, 12_u); + + auto* clamped_coords = b.Min(coords, apparent_size); + auto* clamped_coords_f = b.Convert(ty.vec2f(), clamped_coords); + + auto* modified_coords = + b.Multiply(load_transform_matrix, b.Construct(ty.vec3f(), clamped_coords_f, 1_f)); + auto* load_coords_f = b.Call(ty.vec2f(), core::BuiltinFn::kRound, modified_coords); + auto* load_coords = b.Convert(ty.vec2u(), load_coords_f); + + auto* load = + b.Call(ty.vec4f(), core::BuiltinFn::kTextureLoad, texture, load_coords, 0_u); + + auto* extract_rgb = + b.Construct(ty.vec4f(), b.Swizzle(ty.vec3f(), load, {0u, 1u, 2u}), 1_f); + auto* rgb_result = b.Multiply(extract_rgb, yuv_to_rgb_conversion); + + // Apply gamma correction if needed. + auto* final_result = ApplyGammaCorrect(params, rgb_result->Result()); + b.Return(texture_load_ycbcr_external, b.Construct(ty.vec4f(), final_result, 1_f)); + }); + + return texture_load_ycbcr_external; } /// Gets or creates the texture sample helper function. /// @returns the function - Function* TextureSampleExternal() { - if (texture_sample_external) { - return texture_sample_external; + Function* TextureSampleClampToEdgeMultiplanarExternal() { + if (texture_sample_clamp_to_edge_multiplanar_external) { + return texture_sample_clamp_to_edge_multiplanar_external; } // The helper function implements the following: - // fn textureSampleExternal(plane0 : texture_2d, + // fn textureSampleClampToEdgeMultiplanarExternal(plane0 : texture_2d, // plane1 : texture_2d, - // smp : sampler, - // coord : vec2f, - // params : ExternalTextureParams) ->vec4f { - // let modifiedCoords = (params.sampleTransform * vec3(coord, 1)); - // let plane0_clamped = + // params : ExternalTextureParams, + // tint_sampler : sampler, + // coord : vec2f) ->vec4f { + // let modifiedCoords = params.sampleTransform * vec3(coord, 1); + // let loadCoords = // clamp(modifiedCoords, params.samplePlane0RectMin, params.samplePlane0RectMax); - // var color : vec4; + // + // var color: vec3; + // var alpha: f32 // // if ((params.numPlanes == 1)) { - // color = textureSampleLevel(plane0, smp, plane0_clamped, 0).rgba; + // let val = textureSampleLevel(plane0, tint_sampler, loadCoords, 0); + // color = val.rgb; + // alpha = val.a; // } else { // let plane1_clamped = // clamp(modifiedCoords, params.samplePlane1RectMin, // params.samplePlane1RectMax); - // color = vec4( - // vec4(textureSampleLevel(plane0, smp, plane0_clamped, 0).r, - // textureSampleLevel(plane1, smp, plane1_clamped, 0).rg, 1) * - // params.yuvToRgbConversionMatrix), 1); + // color = vec4(textureSampleLevel(plane0, tint_sampler, loadCoords, 0).r, + // textureSampleLevel(plane1, tint_sampler, plane1_clamped, + // 0).rg, 1) * + // params.yuvToRgbConversionMatrix) + // alpha = 1.f; // } // - // if ((params.doYuvToRgbConversionOnly == 0)) { - // color = vec4(gammaCorrection(color.rgb, params.gammaDecodeParams), color.a); - // color = vec4((params.gamutConversionMatrix * color.rgb), color.a); - // color = vec4(gammaCorrection(color.rgb, params.gammaEncodeParams), color.a); - // } + // color = ApplyGammaCorrect(params, color) // - // return color; + // return vec4f(color, a); // } - texture_sample_external = b.Function("tint_TextureSampleExternal", ty.vec4f()); + texture_sample_clamp_to_edge_multiplanar_external = + b.Function("tint_TextureSampleClampToEdgeMultiplanarExternal", ty.vec4f()); auto* plane_0 = b.FunctionParam("plane_0", SampledTexture()); auto* plane_1 = b.FunctionParam("plane_1", SampledTexture()); auto* params = b.FunctionParam("params", ExternalTextureParams()); auto* sampler = b.FunctionParam("tint_sampler", ty.sampler()); auto* coords = b.FunctionParam("coords", ty.vec2f()); - texture_sample_external->SetParams({plane_0, plane_1, params, sampler, coords}); - b.Append(texture_sample_external->Block(), [&] { - auto* vec2f = ty.vec2f(); - auto* vec3f = ty.vec3f(); - auto* vec4f = ty.vec4f(); - auto* yuv_to_rgb_conversion_only = b.Access(ty.u32(), params, 1_u); + texture_sample_clamp_to_edge_multiplanar_external->SetParams( + {plane_0, plane_1, params, sampler, coords}); + b.Append(texture_sample_clamp_to_edge_multiplanar_external->Block(), [&] { auto* yuv_to_rgb_conversion = b.Access(ty.mat3x4(), params, 2_u); auto* transformation_matrix = b.Access(ty.mat3x2(), params, 6_u); auto* sample_plane0_rect_min = b.Access(ty.vec2f(), params, 8_u); @@ -537,64 +935,110 @@ struct State { auto* sample_plane1_rect_max = b.Access(ty.vec2f(), params, 11_u); auto* modified_coords = - b.Multiply(transformation_matrix, b.Construct(vec3f, coords, 1_f)); - auto* plane0_clamped = + b.Multiply(transformation_matrix, b.Construct(ty.vec3f(), coords, 1_f)); + auto* loadCoords = b.Clamp(modified_coords, sample_plane0_rect_min, sample_plane0_rect_max); - auto* rgb_result = b.InstructionResult(vec3f); + auto* rgb_result = b.InstructionResult(ty.vec3f()); auto* alpha_result = b.InstructionResult(ty.f32()); auto* num_planes = b.Access(ty.u32(), params, 0_u); auto* if_planes_eq_1 = b.If(b.Equal(num_planes, 1_u)); if_planes_eq_1->SetResults(rgb_result, alpha_result); b.Append(if_planes_eq_1->True(), [&] { // Sample the texel from the first plane and split into separate rgb and a values. - auto* texel = b.Call(vec4f, core::BuiltinFn::kTextureSampleLevel, plane_0, sampler, - plane0_clamped, 0_f); - auto* rgb = b.Swizzle(vec3f, texel, {0u, 1u, 2u}); + auto* texel = b.Call(ty.vec4f(), core::BuiltinFn::kTextureSampleLevel, plane_0, + sampler, loadCoords, 0_f); + auto* rgb = b.Swizzle(ty.vec3f(), texel, {0u, 1u, 2u}); auto* a = b.Access(ty.f32(), texel, 3_u); b.ExitIf(if_planes_eq_1, rgb, a); }); b.Append(if_planes_eq_1->False(), [&] { // Sample the y value from the first plane. auto* y = b.Access(ty.f32(), - b.Call(vec4f, core::BuiltinFn::kTextureSampleLevel, plane_0, - sampler, plane0_clamped, 0_f), + b.Call(ty.vec4f(), core::BuiltinFn::kTextureSampleLevel, plane_0, + sampler, loadCoords, 0_f), 0_u); auto* plane1_clamped = b.Clamp(modified_coords, sample_plane1_rect_min, sample_plane1_rect_max); // Sample the uv value from the second plane. - auto* uv = b.Swizzle(vec2f, - b.Call(vec4f, core::BuiltinFn::kTextureSampleLevel, plane_1, - sampler, plane1_clamped, 0_f), + auto* uv = b.Swizzle(ty.vec2f(), + b.Call(ty.vec4f(), core::BuiltinFn::kTextureSampleLevel, + plane_1, sampler, plane1_clamped, 0_f), {0u, 1u}); // Convert the combined yuv value into rgb and set the alpha to 1.0. b.ExitIf(if_planes_eq_1, - b.Multiply(b.Construct(vec4f, y, uv, 1_f), yuv_to_rgb_conversion), 1_f); + b.Multiply(b.Construct(ty.vec4f(), y, uv, 1_f), yuv_to_rgb_conversion), + 1_f); }); // Apply gamma correction if needed. - auto* final_result = b.InstructionResult(vec3f); - auto* if_gamma_correct = b.If(b.Equal(yuv_to_rgb_conversion_only, 0_u)); - if_gamma_correct->SetResult(final_result); - b.Append(if_gamma_correct->True(), [&] { - auto* gamma_decode_params = b.Access(GammaTransferParams(), params, 3_u); - auto* gamma_encode_params = b.Access(GammaTransferParams(), params, 4_u); - auto* gamut_conversion_matrix = b.Access(ty.mat3x3(), params, 5_u); - auto* decoded = b.Call(vec3f, GammaCorrection(), rgb_result, gamma_decode_params); - auto* converted = b.Multiply(gamut_conversion_matrix, decoded); - auto* encoded = b.Call(vec3f, GammaCorrection(), converted, gamma_encode_params); - b.ExitIf(if_gamma_correct, encoded); - }); - b.Append(if_gamma_correct->False(), [&] { // - b.ExitIf(if_gamma_correct, rgb_result); - }); - - b.Return(texture_sample_external, b.Construct(vec4f, final_result, alpha_result)); + auto* final_result = ApplyGammaCorrect(params, rgb_result); + b.Return(texture_sample_clamp_to_edge_multiplanar_external, + b.Construct(ty.vec4f(), final_result, alpha_result)); }); - return texture_sample_external; + return texture_sample_clamp_to_edge_multiplanar_external; + } + + /// Gets or creates the texture sample helper function. + /// @returns the function + Function* TextureSampleClampToEdgeYCBCRExternal() { + if (texture_sample_clamp_to_edge_ycbcr_external) { + return texture_sample_clamp_to_edge_ycbcr_external; + } + + // The helper function implements the following: + // fn textureSampleClampToEdgeYcbcrExternal(texture : texture_2d, + // ycbcr_sampler : sampler, + // coord : vec2f, + // params : ExternalTextureParams) ->vec4f { + // let modifiedCoords = params.sampleTransform * vec3(coord, 1); + // let loadCoords = + // clamp(modifiedCoords, params.samplePlane0RectMin, params.samplePlane0RectMax); + // + // let val = textureSampleLevel(texture, ycbcr_sampler, loadCoords, 0); + // var color = val.rgb * params.yuvToRgbConversionMatrix + // let a = val.a; + // + // color = ApplyGammaCorrect(params, color) + // + // return vec4f(color, a); + // } + texture_sample_clamp_to_edge_ycbcr_external = + b.Function("tint_TextureSampleClampToEdgeYcbcrExternal", ty.vec4f()); + auto* texture = b.FunctionParam("texture", SampledTexture()); + auto* ycbcr_sampler = b.FunctionParam("ycbcr_sampler", ty.sampler()); + auto* params = b.FunctionParam("params", ExternalTextureParams()); + auto* coords = b.FunctionParam("coords", ty.vec2f()); + texture_sample_clamp_to_edge_ycbcr_external->SetParams( + {texture, ycbcr_sampler, params, coords}); + + b.Append(texture_sample_clamp_to_edge_ycbcr_external->Block(), [&] { + auto* yuv_to_rgb_conversion = b.Access(ty.mat3x4(), params, 2_u); + auto* transformation_matrix = b.Access(ty.mat3x2(), params, 6_u); + auto* sample_rect_min = b.Access(ty.vec2f(), params, 8_u); + auto* sample_rect_max = b.Access(ty.vec2f(), params, 9_u); + + auto* modified_coords = + b.Multiply(transformation_matrix, b.Construct(ty.vec3f(), coords, 1_f)); + auto* loadCoords = b.Clamp(modified_coords, sample_rect_min, sample_rect_max); + + auto* texel = b.Call(ty.vec4f(), core::BuiltinFn::kTextureSampleLevel, texture, + ycbcr_sampler, loadCoords, 0_f); + auto* rgb = b.Swizzle(ty.vec3f(), texel, {0u, 1u, 2u}); + auto* colour = b.Multiply(b.Construct(ty.vec4f(), rgb, 1_f), yuv_to_rgb_conversion); + + auto* alpha = b.Swizzle(ty.f32(), texel, {3u}); + + // Apply gamma correction if needed. + auto* final_result = ApplyGammaCorrect(params, colour->Result()); + b.Return(texture_sample_clamp_to_edge_ycbcr_external, + b.Construct(ty.vec4f(), final_result, alpha)); + }); + + return texture_sample_clamp_to_edge_ycbcr_external; } }; @@ -603,8 +1047,8 @@ struct State { Result MultiplanarExternalTexture( Module& ir, const tint::transform::multiplanar::BindingsMap& multiplanar_map) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kMultiplanarExternalTextureCapabilities, - "core.MultiplanarExternalTexture")); + core::ir::AssertValid(ir, kMultiplanarExternalTextureCapabilities, + "before core.MultiplanarExternalTexture"); return State{multiplanar_map, ir}.Process(); } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.h index 680f75756..026180b99 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_external_texture.h @@ -41,9 +41,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kMultiplanarExternalTextureCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// MultiplanarExternalTexture is a transform that splits texture_external bindings into two diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_options.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_options.h index 51d8a8532..08fa980bb 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_options.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/multiplanar_options.h @@ -35,8 +35,8 @@ namespace tint::transform::multiplanar { /// This struct identifies the binding groups and locations for new bindings to -/// use when transforming a texture_external instance. -struct BindingPoints { +/// use when transforming a multiplanar texture_external instance. +struct MultiplanarTexture { /// The desired binding location of the texture_2d representing plane #1 when /// a texture_external binding is expanded. BindingPoint plane_1; @@ -45,13 +45,27 @@ struct BindingPoints { BindingPoint params; /// Reflect the fields of this class so that it can be used by tint::ForeachField() - TINT_REFLECT(BindingPoints, plane_1, params); + TINT_REFLECT(MultiplanarTexture, plane_1, params); +}; + +/// This struct identifies the binding groups and locations for new bindings to +/// use when transforming a YCBcr texture_external instance. +struct YCBCRTexture { + /// The desired binding location of the sampler when a texture_external binding is expanded. + BindingPoint sampler; + /// The desired binding location of the ExternalTextureParams uniform when a + /// texture_external binding is expanded. + BindingPoint params; + + /// Reflect the fields of this class so that it can be used by tint::ForeachField() + TINT_REFLECT(YCBCRTexture, sampler, params); }; /// BindingsMap is a map where the key is the binding location of a /// texture_external and the value is a struct containing the desired /// locations for new bindings expanded from the texture_external instance. -using BindingsMap = std::unordered_map; +using BindingsMap = + std::unordered_map>; } // namespace tint::transform::multiplanar diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.cc index 3fe55b30f..b7456ba01 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.cc @@ -58,11 +58,6 @@ struct State { core::type::Manager& ty{ir.Types()}; Result Run() { - if (config.internal_immediate_data.empty()) { - return ImmediateDataLayout{}; - } - - ImmediateDataLayout layout; Var* user_defined_immediates = nullptr; Vector members; @@ -82,6 +77,10 @@ struct State { } user_defined_immediates = var; + if (ptr->StoreType()->Size() > kMaxImmediateBlockSize) { + return Failure("user-defined immediate data exceeds maximum immediate block size"); + } + // Assume that user-defined constants start at offset 0 until Dawn tells us otherwise. members.Push(ty.Get(ir.symbols.New("user_immediate_data"), ptr->StoreType(), @@ -92,12 +91,18 @@ struct State { /* attributes */ IOAttributes{})); } + ImmediateDataLayout layout; + if (config.internal_immediate_data.empty()) { + return layout; + } + // Create the structure and immediate data variable. for (auto& internal : config.internal_immediate_data) { auto offset = internal.first; if (!members.IsEmpty()) { - if (members.Back()->Offset() + members.Back()->Size() > offset) { + if (static_cast(members.Back()->Offset()) + members.Back()->Size() > + offset) { return Failure("immediate offset for '" + internal.second.name.Name() + "' overlaps with previous member '" + members.Back()->Name().Name() + "'"); @@ -108,7 +113,8 @@ struct State { "' must be aligned to " + std::to_string(internal.second.type->Align()) + " bytes"); } - if (offset + internal.second.type->Size() > kMaxImmediateBlockSize) { + if (static_cast(offset) + internal.second.type->Size() > + kMaxImmediateBlockSize) { return Failure("immediate '" + internal.second.name.Name() + "' exceeds maximum immediate block size"); } @@ -124,11 +130,10 @@ struct State { /* attributes */ IOAttributes{})); } - auto* immediate_constant_struct = + auto* immediate_struct = ty.Struct(ir.symbols.New("tint_immediate_data_struct"), std::move(members)); - immediate_constant_struct->SetStructFlag(type::kBlock); - layout.var = - b.Var("tint_immediate_data", core::AddressSpace::kImmediate, immediate_constant_struct); + immediate_struct->SetStructFlag(type::kBlock); + layout.var = b.Var("tint_immediate_data", core::AddressSpace::kImmediate, immediate_struct); ir.root_block->Append(layout.var); // Update uses of the user defined immediate data variable. @@ -149,13 +154,11 @@ struct State { Result PrepareImmediateData(Module& ir, const PrepareImmediateDataConfig& config) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllow8BitIntegers, - core::ir::Capability::kAllowNonCoreTypes, - }, - "core.PrepareImmediateData")); + core::ir::AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + }, + "before core.PrepareImmediateData"); return State{config, ir}.Run(); } diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.h index 6021d0cde..7d27c0d6e 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/prepare_immediate_data.h @@ -31,7 +31,7 @@ #include #include "src/tint/utils/containers/hashmap.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" #include "src/tint/utils/symbol/symbol.h" @@ -46,7 +46,7 @@ class Type; namespace tint::core::ir::transform { -/// A descriptor for an internal immediate constant. +/// A descriptor for an internal immediate. struct InternalImmediateData { Symbol name; const core::type::Type* type = nullptr; @@ -93,7 +93,7 @@ struct PrepareImmediateDataConfig { /// data to combine both user-defined and internally used immediate data values. /// @param module the module to transform /// @param config the transform config -/// @returns the generated immediate constant layout or failure +/// @returns the generated immediate layout or failure Result PrepareImmediateData(Module& module, const PrepareImmediateDataConfig& config); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.cc index 3a123dea2..15a7f68e0 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.cc @@ -169,8 +169,7 @@ struct State { } // namespace Result PreservePadding(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kPreservePaddingCapabilities, "core.PreservePadding")); + core::ir::AssertValid(ir, "before core.PreservePadding"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.h index cc08dea59..a28c1c3ca 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/preserve_padding.h @@ -38,14 +38,6 @@ class Module; namespace tint::core::ir::transform { -/// The capabilities that the transform can support. -const core::ir::Capabilities kPreservePaddingCapabilities{ - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, -}; - /// PreservePadding is a transform that decomposes stores of whole structure and array types to /// preserve padding bytes. /// diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.cc index 573b253c4..fe6c06426 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.cc @@ -116,8 +116,8 @@ struct State { } // namespace Result PreventInfiniteLoops(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kPreventInfiniteLoopsCapabilities, "core.PreventInfiniteLoops")); + core::ir::AssertValid(ir, kPreventInfiniteLoopsCapabilities, + "before core.PreventInfiniteLoops"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.h index 11a4cc9c0..242bfb606 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/prevent_infinite_loops.h @@ -40,8 +40,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kPreventInfiniteLoopsCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// PreventInfiniteLoops is a transform that injects an additional exit condition into loops that diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/propagate_buffer_sizes.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/propagate_buffer_sizes.cc new file mode 100644 index 000000000..de8523734 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/propagate_buffer_sizes.cc @@ -0,0 +1,292 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/tint/lang/core/ir/transform/propagate_buffer_sizes.h" + +#include "src/tint/lang/core/ir/builder.h" +#include "src/tint/lang/core/ir/module.h" +#include "src/tint/lang/core/ir/traverse.h" +#include "src/tint/lang/core/ir/validator.h" +#include "src/tint/utils/containers/hashmap.h" +#include "src/tint/utils/containers/hashset.h" + +using namespace tint::core::fluent_types; // NOLINT +using namespace tint::core::number_suffixes; // NOLINT + +namespace tint::core::ir::transform { + +namespace { + +/// PIMPL state for the transform. +struct State { + /// The IR module. + Module& ir; + + /// The IR builder. + Builder b{ir}; + + /// The type manager. + core::type::Manager& ty{ir.Types()}; + + void Process() { + auto ordered_funcs = ir.DependencyOrderedFunctions(); + for (auto* func : ordered_funcs) { + ProcessFunction(func); + } + } + + void ProcessFunction(Function* func) { + // For each buffer_view call in `func`: + // 1. If the call is rooted by a constant-sized buffer, propagate the size + // 2. If the call is rooted by a runtime-sized param, add to `calls` + // 3. Skip runtime-sized variable roots. + Hashmap, 8> calls; + Traverse(func->Block(), [this, &calls](CoreBuiltinCall* call) { + if (call->Func() != BuiltinFn::kBufferView && + call->Func() != BuiltinFn::kBufferArrayView && + call->Func() != BuiltinFn::kBufferLength) { + return; + } + + if (call->Func() != BuiltinFn::kBufferLength) { + AdjustOperands(call); + } + + auto* root = RootIdentifier(call->Args()[0]); + auto* buffer_ty = root->Type()->UnwrapPtr()->As(); + if (buffer_ty->Count()->Is()) { + if (auto* param = root->As()) { + calls.GetOrAddZero(param).Push(call); + } + return; + } + + TINT_IR_ASSERT(ir, buffer_ty->Count()->Is()); + call->AppendArg(b.Constant(u32(buffer_ty->ConstantCount().value()))); + }); + + if (calls.IsEmpty()) { + return; + } + + // For each parameter tracked above: + // 1. Find the roots (either a sized parameter or global var). + // 2. If there is a single root: + // i. If the count is constant, propagate it + // ii. Otherwise, skip it. + // 3. If there are multiple roots: + // i. Add a parameter to the function + // ii. Propagate that parameter to each associated buffer view call + // iii. For each call to `func`, append a new call to bufferLength as the new arg + // + // Since function are processed in dependency order, this will build a chain of bufferLength + // calls. Each bufferLength call will be processed similarly and have the length appended. + // Later extra calls can be elided. + auto func_uses = func->UsagesSorted(); + auto num_params = func->Params().Length(); + for (size_t i = 0; i < num_params; i++) { + auto* param = func->Params()[i]; + if (!calls.Contains(param)) { + continue; + } + + Hashset roots; + TraceRoots(param, roots); + if (roots.Count() == 1) { + auto* root = roots.Vector()[0]; + auto* buffer_ty = root->Type()->UnwrapPtr()->As(); + auto count = buffer_ty->ConstantCount(); + if (count != std::nullopt) { + auto param_calls = calls.Get(param); + for (auto* buffer_call : *param_calls) { + buffer_call->AppendArg(b.Constant(u32(count.value()))); + } + } + + continue; + } + + for (auto use : func_uses) { + auto* inst = use.instruction; + if (!inst->Is()) { + continue; + } + + auto* call = inst->As(); + b.InsertBefore(call, [&] { + auto len = + b.Call(ty.u32(), BuiltinFn::kBufferLength, call->Args()[param->Index()]); + call->AppendArg(len->Result()); + }); + } + + auto new_param = b.FunctionParam(ty.u32()); + func->AppendParam(new_param); + auto param_calls = calls.Get(param); + for (auto* buffer_call : *param_calls) { + buffer_call->AppendArg(new_param); + } + } + } + + /// Adjusts the runtime values of buffer[Array]View arguments + /// Offset = offset & ~(align(store_ty) - 1) + /// Size = (((size - offset) / stride) * stride) + offset + /// @param call The builtin call + void AdjustOperands(CoreBuiltinCall* call) { + auto* store_ty = call->Result()->Type()->UnwrapPtr(); + auto* offset = call->Args()[1]; + if (auto* offset_cnst = offset->As()) { + auto offset_value = offset_cnst->Value()->ValueAs(); + if ((offset_value & store_ty->Align()) != 0) { + call->SetArg(1, b.Constant(u32(offset_value & ~(store_ty->Align() - 1)))); + } + } else { + b.InsertBefore(call, [&] { + // Modify offset to be aligned to the result store type's alignment. + offset = b.InsertBitcastIfNeeded(ty.u32(), offset); + offset = b.And(offset, u32(~(store_ty->Align() - 1)))->Result(); + call->SetArg(1, offset); + }); + } + + if (call->Func() == BuiltinFn::kBufferView) { + return; + } + + auto* size = call->Args()[2]; + uint32_t ty_offset = 0; + uint32_t ty_stride = 0; + TINT_IR_ASSERT(ir, !store_ty->HasFixedFootprint()); + if (auto* str_ty = store_ty->As()) { + auto last = str_ty->Members().Back(); + auto last_ty = last->Type(); + TINT_IR_ASSERT(ir, last_ty->Is()); + ty_offset = last->Offset(); + ty_stride = last_ty->As()->ImplicitStride(); + } else { + TINT_IR_ASSERT(ir, store_ty->Is()); + ty_stride = store_ty->As()->ImplicitStride(); + } + if (auto* size_cnst = size->As()) { + auto size_value = size_cnst->Value()->ValueAs(); + if ((size_value - ty_offset) % ty_stride != 0) { + call->SetArg( + 2, b.Constant( + u32((((size_value - ty_offset) / ty_stride) * ty_stride) + ty_offset))); + } + } else { + b.InsertBefore(call, [&] { + // Round down to a multiple of stride, but don't include the struct offset in that + // rounding. + size = b.InsertBitcastIfNeeded(ty.u32(), size); + if (ty_offset != 0) { + // Avoid potential underflow if size < ty_offset. + size = b.Call(ty.u32(), BuiltinFn::kMax, size, u32(ty_offset))->Result(); + size = b.Subtract(size, u32(ty_offset))->Result(); + } + size = b.Divide(size, u32(ty_stride))->Result(); + size = b.Multiply(size, u32(ty_stride))->Result(); + if (ty_offset != 0) { + size = b.Add(size, u32(ty_offset))->Result(); + } + call->SetArg(2, size); + }); + } + } + + /// Find the roots of `param`. Each root is either: + /// * A global variable, or + /// * A constant-sized buffer function parameter + /// @param param The function parameter + /// @param roots The set of roots + void TraceRoots(FunctionParam* param, Hashset& roots) { + auto func_uses = param->Function()->UsagesSorted(); + for (auto use : func_uses) { + auto* inst = use.instruction; + if (!inst->Is()) { + continue; + } + auto* call = inst->As(); + auto* arg = call->Args()[param->Index()]; + auto* root = RootIdentifier(arg); + if (auto* root_param = root->As()) { + auto* store_ty = root_param->Type()->UnwrapPtr(); + TINT_IR_ASSERT(ir, store_ty->Is()); + auto* buffer_ty = store_ty->As(); + auto* count = buffer_ty->Count(); + if (count->Is()) { + TraceRoots(root_param, roots); + } else { + roots.Add(root_param); + } + } else { + roots.Add(root); + } + } + } + + /// Find the root identifier of `value` + /// @param value The value (a buffer) to trace + /// @returns The root identifier (either global var or function parameter) + Value* RootIdentifier(Value* value) { + Value* result = nullptr; + while (value) { + TINT_IR_ASSERT(ir, value->Alive()); + value = tint::Switch( + value, // + [&](InstructionResult* res) { + // Don't need to check accesses since buffers can't be used with them. + auto* inst = res->Instruction(); + return tint::Switch( + inst, // + [&](Let* let) { return let->Value(); }, + [&](Var* var) { + result = var->Result(); + return nullptr; + }, + TINT_ICE_ON_NO_MATCH); + }, + [&](FunctionParam* param) { + result = param; + return nullptr; + }, + TINT_ICE_ON_NO_MATCH); + } + return result; + } +}; +} // namespace + +Result PropagateBufferSizes(Module& ir) { + AssertValid(ir, kPropagateBufferSizesCapabilities, "before core.PropagateBufferSizes"); + + State{ir}.Process(); + + return Success; +} +} // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/propagate_buffer_sizes.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/propagate_buffer_sizes.h new file mode 100644 index 000000000..ffe4d1a04 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/propagate_buffer_sizes.h @@ -0,0 +1,53 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_CORE_IR_TRANSFORM_PROPAGATE_BUFFER_SIZES_H_ +#define SRC_TINT_LANG_CORE_IR_TRANSFORM_PROPAGATE_BUFFER_SIZES_H_ + +#include "src/tint/lang/core/ir/validator.h" +#include "src/tint/utils/result.h" + +// Forward declarations. +namespace tint::core::ir { +class Module; +} + +namespace tint::core::ir::transform { + +/// The capabilities that the transform can support. +const Capabilities kPropagateBufferSizesCapabilities{ + Capability::kAllow16BitIntegers, +}; + +/// PropagateBufferSizes is a transform that propagates buffer sizes through the call tree. +/// @param module The module +/// @returns success or failure +Result PropagateBufferSizes(Module& module); + +} // namespace tint::core::ir::transform + +#endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_PROPAGATE_BUFFER_SIZES_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_continue_in_switch.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_continue_in_switch.cc index 74c6fbafc..fd26c07c5 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_continue_in_switch.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_continue_in_switch.cc @@ -120,16 +120,11 @@ struct State { } // namespace Result RemoveContinueInSwitch(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - }, - "core.RemoveContinueInSwitch")); + core::ir::AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + }, + "before core.RemoveContinueInSwitch"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.cc index 36f7dc57f..1d519e84b 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.cc @@ -163,8 +163,8 @@ struct State { } // namespace Result RemoveTerminatorArgs(Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kRemoveTerminatorArgsCapabilities, "core.RemoveTerminatorArgs")); + core::ir::AssertValid(ir, kRemoveTerminatorArgsCapabilities, + "before core.RemoveTerminatorArgs"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.h index ddac57a83..9f422e4b2 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_terminator_args.h @@ -40,19 +40,8 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kRemoveTerminatorArgsCapabilities{ - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, core::ir::Capability::kAllow64BitIntegers, - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPointSizeBuiltin, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowAnyLetType, - core::ir::Capability::kAllowModuleScopeLets, - core::ir::Capability::kMslAllowEntryPointInterface, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, core::ir::Capability::kLoosenValidationForShaderIO, }; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_uniform_vector_component_loads.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_uniform_vector_component_loads.cc index 7905f0b0b..b00ceaaf1 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_uniform_vector_component_loads.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/remove_uniform_vector_component_loads.cc @@ -78,13 +78,11 @@ struct State { } // namespace Result RemoveUniformVectorComponentLoads(core::ir::Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, - }, - "core.RemoveUniformVectorComponentLoads")); + core::ir::AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + }, + "before core.RemoveUniformVectorComponentLoads"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.cc index 76e06a6f0..40bdfa0ff 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.cc @@ -301,8 +301,7 @@ struct State { } // namespace Result RenameConflicts(core::ir::Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kRenameConflictsCapabilities, "core.RenameConflicts")); + core::ir::AssertValid(ir, kRenameConflictsCapabilities, "before core.RenameConflicts"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.h index c74a4bc3f..c728f728b 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/rename_conflicts.h @@ -40,19 +40,8 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kRenameConflictsCapabilities{ - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, core::ir::Capability::kAllow64BitIntegers, - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPointSizeBuiltin, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowAnyLetType, - core::ir::Capability::kAllowModuleScopeLets, - core::ir::Capability::kMslAllowEntryPointInterface, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, core::ir::Capability::kLoosenValidationForShaderIO, }; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.cc index 4299fc372..7db93fae2 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.cc @@ -35,6 +35,7 @@ #include "src/tint/lang/core/ir/var.h" #include "src/tint/lang/core/type/manager.h" #include "src/tint/lang/core/type/resource_type.h" +#include "src/tint/lang/core/type/sampled_texture.h" namespace tint::core::ir::transform { namespace { @@ -42,10 +43,60 @@ namespace { using namespace tint::core::fluent_types; // NOLINT using namespace tint::core::number_suffixes; // NOLINT -/// PIMPL state for the transform. +/// Th resource_table transform handles the removal of the `getResource` and `hasResource` calls and +/// replaces them with accesses into backend specific arrays. The backend specific parts are handled +/// by the `ResourceTableHelper` which is attached to the transform. +/// +/// There are a number of cases this transform handles, and it makes assumptions based on the +/// information provided to it from the API. There is a bi-directional relationship in the +/// validation for the combined texture/sampler calls with the API. +/// +/// We have to handle several cases in here: +/// +/// 1. `hasResource` -- this is just changed to a validation check that the type in the WGSL +/// template (e.g. `hasResource>(n)`) matches the ResourceType that Dawn has +/// stored into the metadata table for the slot `n`. +/// +/// 2. `getResource` with no usages -- this just gets removed, we don't use the value returned so we +/// don't actually need to do anything. +/// +/// 3. `getResource` used without an associated sampler -- In this case we just need to +/// check that the type in `getResource` matches the type in slot `n` of the metadata +/// table. If the ResourceType does not match then we will use the default resource provided by +/// Dawn for the `texture_*` type. +/// +/// 4. `getResource` used with a `getResource` -- In this case we need to +/// validate that the `getResource(t)` is correct against metadata slot `t`, and the +/// `getResource(s)` is correct against the metadata slot `s`. Additionally we need to +/// validate if the `sampler` is `filtering` then the `texture` is a `filterable` texture. If +/// the texture/sampler pair are incompatible (an unfilterable texture paired with a filtering +/// sampler) then we will return a `0` value result. +/// +/// ``` +/// if (sampler.kind == Filtering && IsUnFilterable(texture.kind)) { +/// value = vec4(0) +/// } else { +/// value = textureSample(t, s) +/// } +/// ``` +/// +/// Note, this means there is no substitution of default texture or sampler. +/// +/// 5. `getResource` used with a bindful sampler -- In this case we need to check that +/// the type in `getResource(t)` matches the type in the slot `t` of the metadata +/// table. The API will provide information to Tint on the ResourceKind of the sampler, which is +/// known at pipeline creation time. We will then validate that the texture/sampler pair are +/// compatible (same as #4). If the are not compatible we will return a 0 value. +/// +/// Note, this means there is no substitution of default texture or sampler. +/// +/// 6. `getResource` used with a bindful texture -- In this case we will validate that the +/// ResourceType of the element at slot `n` is a sampler. We then get the `ResourceType` for the +/// bindful texture as reported by the API side. At this point we do the same validation as #5. + struct State { /// The configuration. - const ResourceTableConfig& config; + const std::optional& config; /// The IR module. core::ir::Module& ir; @@ -59,92 +110,201 @@ struct State { /// The type manager. core::type::Manager& ty{ir.Types()}; + /// The storage buffer used to hold API metadata + core::ir::Var* storage_buffer = nullptr; + + /// Map from a tint Type to the `var` which holds the resource table of that type + Hashmap var_for_type{}; + + /// Maps resource_index value to the default offset for that type + std::unordered_map resource_type_to_default_idx{}; + + /// Information about an item that we need to get from the resource table. + struct Info { + const core::type::Type* binding_type; + core::ir::Value* slot_idx; + size_t operand_idx; + }; + /// A list of instructions which need to be replaced with the, possibly, two indices which are + /// using a resource_table element. + struct CallArgs { + std::optional texture; + std::optional sampler; + }; + Hashmap sampled_call_replacements{}; + /// Process the module. - void Process() { - Hashmap var_for_type; - core::ir::Var* sb = nullptr; - b.Append(ir.root_block, [&] { - var_for_type = helper->GenerateVars(b, config.resource_table_binding, - config.default_binding_type_order); - sb = InjectStorageBuffer(config.storage_buffer_binding); - }); - - std::unordered_map resource_type_to_idx; - size_t def_size = config.default_binding_type_order.size(); - for (size_t i = 0; i < def_size; ++i) { - auto res_ty = static_cast(config.default_binding_type_order[i]); - resource_type_to_idx.insert({res_ty, uint32_t(i)}); - } - - std::vector to_delete; + Result Process() { + // Find calls to hasResource() and getResource(). + Vector has_resource_calls; + Vector get_resource_calls; for (auto* inst : ir.Instructions()) { auto* call = inst->As(); if (call == nullptr) { continue; } - if (call->Func() != core::BuiltinFn::kGetResource && - call->Func() != core::BuiltinFn::kHasResource) { - continue; + if (call->Func() == core::BuiltinFn::kHasResource) { + has_resource_calls.Push(call); + } else if (call->Func() == core::BuiltinFn::kGetResource) { + get_resource_calls.Push(call); } + } + if (has_resource_calls.IsEmpty() && get_resource_calls.IsEmpty()) { + return Success; + } + if (!config.has_value()) { + return Failure{"hasResource and getResource require a resource table"}; + } + InjectRootBlockEntries(); + CalculateDefaultBindingIndices(); + + ReplaceHasResourceCalls(has_resource_calls); + ReplaceGetResourceCalls(get_resource_calls); + + return Success; + } + + std::pair GetResourceTableCallInfo( + core::ir::CoreBuiltinCall* call) { + TINT_IR_ASSERT( + ir, std::holds_alternative(call->ExplicitTemplateParams()[0])); + const type::Type* binding_ty = + std::get(call->ExplicitTemplateParams()[0]); + ir::Value* idx = b.InsertConvertIfNeeded(ty.u32(), call->Args()[0]); + return {binding_ty, idx}; + } + + void ReplaceHasResourceCalls(const Vector& calls) { + for (auto* call : calls) { b.InsertBefore(call, [&] { - switch (call->Func()) { - case core::BuiltinFn::kHasResource: { - auto* binding_ty = call->ExplicitTemplateParams()[0]; - auto* idx = call->Args()[0]; - if (idx->Type()->IsSignedIntegerScalar()) { - idx = b.Convert(ty.u32(), idx)->Result(); - } - GenHasResource(call->DetachResult(), binding_ty, idx, sb); - break; - } - case core::BuiltinFn::kGetResource: { - auto* binding_ty = call->ExplicitTemplateParams()[0]; - auto* idx = call->Args()[0]; - if (idx->Type()->IsSignedIntegerScalar()) { - idx = b.Convert(ty.u32(), idx)->Result(); - } - GenGetResource(call->DetachResult(), binding_ty, idx, sb, var_for_type, - resource_type_to_idx); - break; - } - default: - TINT_IR_UNREACHABLE(ir); + auto [binding_type, idx] = GetResourceTableCallInfo(call); + GenHasResource(call->DetachResult(), binding_type, idx); + }); + call->Destroy(); + } + } + + void ReplaceGetResourceCalls(const Vector& calls) { + for (auto* call : calls) { + b.InsertBefore(call, [&] { + auto [binding_type, idx] = GetResourceTableCallInfo(call); + for (auto& usage : call->Result()->UsagesSorted()) { + ReplaceGetResourceCallUsage(usage, binding_type, idx); } - to_delete.push_back(call); }); } - for (auto* inst : to_delete) { - inst->Destroy(); + // We should have gathered the potential texture/sampler pair needed for the call so we can + // now replace all the sampled calls. + for (auto& entry : sampled_call_replacements) { + GenSampledGetResource(entry.key, entry.value); } + + // Destroy all known getResource calls, they should have been replaced above + for (auto* call : calls) { + TINT_IR_ASSERT(ir, call->Result()->UsagesUnsorted().IsEmpty()); + call->Destroy(); + } + } + + void ReplaceGetResourceCallUsage(const Usage& usage, + const type::Type* binding_type, + ir::Value* idx) { + ir::CoreBuiltinCall* call = usage.instruction->As(); + TINT_IR_ASSERT(ir, call); + + switch (call->Func()) { + case core::BuiltinFn::kTextureStore: + case core::BuiltinFn::kTextureLoad: + case core::BuiltinFn::kTextureDimensions: + case core::BuiltinFn::kTextureNumLayers: + case core::BuiltinFn::kTextureNumLevels: + case core::BuiltinFn::kTextureNumSamples: { + // Each of these usages just require the texture so they can be replaced + // immediately, there is no extra validation which needs to happen. + + auto* has_result = b.InstructionResult(ty.bool_()); + GenHasResource(has_result, binding_type, idx); + + ir::InstructionResult* res = + GenValidateAndGetFromResourceTable(has_result, binding_type, idx); + call->SetOperand(usage.operand_index, res); + break; + } + case core::BuiltinFn::kTextureGather: + case core::BuiltinFn::kTextureGatherCompare: + case core::BuiltinFn::kTextureSample: + case core::BuiltinFn::kTextureSampleBias: + case core::BuiltinFn::kTextureSampleCompare: + case core::BuiltinFn::kTextureSampleCompareLevel: + case core::BuiltinFn::kTextureSampleGrad: + case core::BuiltinFn::kTextureSampleLevel: + case core::BuiltinFn::kTextureSampleBaseClampToEdge: { + // These calls are all combined with a sampler, this means we can't do the checks at + // this point as the sampler may also be a getResource call. So, store the usage + // away and continue. + Info call_info{ + .binding_type = binding_type, + .slot_idx = idx, + .operand_idx = usage.operand_index, + }; + + auto& info = sampled_call_replacements.GetOrAddZeroEntry(call); + if (binding_type->Is()) { + info.value.texture = call_info; + } else { + info.value.sampler = call_info; + } + break; + } + default: { + TINT_IR_UNREACHABLE(ir) << "unknown builtin function: " << call->Func(); + } + } + } + + // Get the type id from the metadata buffer + core::ir::InstructionResult* GetTypeId(core::ir::Value* idx) { + auto* metadata_access = b.Access(ty.ptr(), storage_buffer, 1_u, idx); + return b.Load(metadata_access)->Result(); + } + + bool IsSampler(const core::type::Type* binding_type) const { + auto res_type = core::type::TypeToResourceType(binding_type); + return tint::IsSampler(res_type); } // Note, assumes it's called inside a builder append block. void GenHasResource(core::ir::InstructionResult* result, - const core::type::Type* type, - core::ir::Value* idx, - core::ir::Var* storage_buffer) { + const core::type::Type* binding_type, + core::ir::Value* idx) { + // Get the table's API size, which is stored at index 0 in the metadata buffer auto* length = b.Access(ty.ptr(), storage_buffer, 0_u); - auto* len_check = b.LessThan(idx, b.Load(length)); + ir.SetName(length, "tint_storage_metadata_length"); + auto* len_check = b.LessThan(idx, b.Load(length)); auto* has_check = b.If(len_check); has_check->SetResult(result); b.Append(has_check->True(), [&] { - auto* type_val = b.Access(ty.ptr(), storage_buffer, 1_u, idx); - auto* v = b.Load(type_val); + auto* metadata_val = GetTypeId(idx); - ResourceType resource_ty = core::type::TypeToResourceType(type); + ir::Value* type_id = nullptr; + if (config->get_sampler_index_from_metadata && IsSampler(binding_type)) { + // Type id is in lower 16 bits + type_id = b.And(metadata_val, u32(0xFFFF))->Result(); + } else { + type_id = metadata_val; + } core::ir::Value* eq = nullptr; - std::vector conv = core::type::ConvertsFrom(type); + std::vector conv = core::type::ConvertsFrom(binding_type); if (!conv.empty()) { - auto* conv_ty = ty.vec(ty.u32(), static_cast(conv.size()) + 1); - auto* lhs = b.Construct(conv_ty, v); + auto* conv_ty = ty.vec(ty.u32(), static_cast(conv.size())); + auto* lhs = b.Construct(conv_ty, type_id); Vector vals; - vals.Push(b.Value(u32(resource_ty))); for (auto& r : conv) { vals.Push(b.Value(u32(r))); } @@ -153,7 +313,8 @@ struct State { auto* cmp = b.Equal(lhs, rhs); eq = b.Call(ty.bool_(), core::BuiltinFn::kAny, cmp)->Result(); } else { - eq = b.Equal(v, u32(resource_ty))->Result(); + ResourceType resource_ty = core::type::TypeToResourceType(binding_type); + eq = b.Equal(type_id, u32(resource_ty))->Result(); } b.ExitIf(has_check, eq); }); @@ -162,55 +323,306 @@ struct State { } // Note, assumes it's called inside a builder append block. - void GenGetResource(core::ir::InstructionResult* result, - const core::type::Type* type, - core::ir::Value* idx, - core::ir::Var* storage_buffer, - const Hashmap& alias_for_type, - const std::unordered_map& resource_type_to_idx) { - auto* has_result = b.InstructionResult(ty.bool_()); - GenHasResource(has_result, type, idx, storage_buffer); - + ir::InstructionResult* GenValidateAndGetFromResourceTable(core::ir::Value* has_result, + const core::type::Type* binding_type, + core::ir::Value* idx) { auto* get_check = b.If(has_result); auto* res = b.InstructionResult(ty.u32()); get_check->SetResult(res); - auto alias = alias_for_type.Get(type); - TINT_IR_ASSERT(ir, alias); + auto var = var_for_type.Get(binding_type); + TINT_IR_ASSERT(ir, var); + // Table lookup succeeded, use the input index b.Append(get_check->True(), [&] { b.ExitIf(get_check, idx); }); + // Table lookup failed, so get default resource located at the end of the table, + // at API size + resource type index. + // + // For textures which can be filterable, the default will be the filterable variant. + // Otherwise it will be unfilterable. b.Append(get_check->False(), [&] { - auto res_type = core::type::TypeToResourceType(type); - auto idx_iter = resource_type_to_idx.find(res_type); - TINT_IR_ASSERT(ir, idx_iter != resource_type_to_idx.end()); - - auto* len_access = b.Access(ty.ptr(), storage_buffer, 0_u); - auto* num_elements = b.Load(len_access); - - auto* r = b.Add(u32(idx_iter->second), num_elements); - + ir::Value* r = GetDefaultForIndex(core::type::DefaultResourceTypeFor(binding_type)); b.ExitIf(get_check, r); }); - // TODO(439627523): Fix pointer access - auto* ptr_ty = ty.ptr(handle, type, read); - auto* access = b.Access(ptr_ty, (*alias)->Result(), res); - b.LoadWithResult(result, access); + return GenGetResource(res, binding_type)->Result(); } - core::ir::Var* InjectStorageBuffer(const BindingPoint& bp) { - auto* str = ty.Struct(ir.symbols.New("tint_resource_table_metadata_struct"), - Vector{ - {ir.symbols.New("array_length"), ty.u32()}, - {ir.symbols.New("bindings"), ty.array()}, - }); + // We have a bind-ful texture/sampler, get the ResourceKind the API reported + ir::Value* GetBindfulKind(ir::CoreBuiltinCall* call, size_t idx) { + core::ir::InstructionResult* opt_res = + call->Operands()[idx]->As(); + TINT_IR_ASSERT(ir, opt_res); - auto* sb_ty = ty.ptr(storage, str, read); - auto* sb = b.Var("tint_resource_table_metadata", sb_ty); - sb->SetBindingPoint(bp.group, bp.binding); + core::ir::Var* var = RootVarFor(opt_res); + TINT_IR_ASSERT(ir, var); - return sb; + auto iter = config->binding_to_resource_type.find(var->BindingPoint().value()); + TINT_IR_ASSERT(ir, iter != config->binding_to_resource_type.end()); + + return b.Constant(u32(iter->second)); + } + + // Returns the root Var for `value` by walking up the chain of instructions, or nullptr if none + // is found. + Var* RootVarFor(Value* value) { + Var* result = nullptr; + while (value) { + TINT_IR_ASSERT(ir, value->Alive()); + + auto* res = value->As(); + TINT_IR_ASSERT(ir, res); + + // value was emitted by an instruction + auto* inst = res->Instruction(); + value = tint::Switch( + inst, + [&](Load* l) { + ir::InstructionResult* from = l->From()->As(); + TINT_IR_ASSERT(ir, from); + + result = from->Instruction()->As(); // Done + TINT_IR_ASSERT(ir, result); + + return nullptr; + }, + [&](Var* var) { + result = var; + return nullptr; // Done + }, + TINT_ICE_ON_NO_MATCH); + } + return result; + } + + // We have a bind-less texture/sampler, we need to verify the ResourceKind matches what we need + // and substitute in a default if needed. + ir::InstructionResult* GetBindlessKind(ir::CoreBuiltinCall* call, + const Info& info, + bool is_sampler_comparison_call, + std::string_view name) { + ir::InstructionResult* resource_kind = nullptr; + b.InsertBefore(call, [&] { + // Determine if the slot kind matches the type in WGSL + auto* has_result = b.InstructionResult(ty.bool_()); + GenHasResource(has_result, info.binding_type, info.slot_idx); + + if (!is_sampler_comparison_call) { + // Get the ResourceKind for the resource + core::ir::If* if_ = b.If(has_result); + resource_kind = b.InstructionResult(ty.u32()); + if_->SetResult(resource_kind); + + b.Append(if_->True(), [&] { // + b.ExitIf(if_, GetTypeId(info.slot_idx)); + }); + b.Append(if_->False(), [&] { + ResourceType res_type = core::type::DefaultResourceTypeFor(info.binding_type); + b.ExitIf(if_, u32(res_type)); + }); + ir.SetName(resource_kind, name); + } + + // Get the resource from the table and update the argument + ir::InstructionResult* res = + GenValidateAndGetFromResourceTable(has_result, info.binding_type, info.slot_idx); + + call->SetOperand(info.operand_idx, res); + }); + return resource_kind; + } + + ir::Value* GetKind(ir::CoreBuiltinCall* call, + const std::optional& opt, + bool is_sampler_comparison_call, + size_t idx, + std::string_view name) { + core::ir::Value* kind = nullptr; + if (opt.has_value()) { + kind = GetBindlessKind(call, opt.value(), is_sampler_comparison_call, name); + } else if (!is_sampler_comparison_call) { + kind = GetBindfulKind(call, idx); + } + return kind; + } + + ir::Value* ConstructTextureFilterableCheck(const type::Type* tex_ty, ir::Value* texture_kind) { + const type::SampledTexture* samp_ty = tex_ty->As(); + // Only sampled texture types can be filterable + if (!samp_ty) { + return b.Constant(false); + } + // Only floating point sampled textures can be filterable + if (samp_ty->Type()->IsAnyOf()) { + return b.Constant(false); + } + + ResourceType res_type = core::type::DefaultResourceTypeFor(tex_ty); + if (texture_kind->Is()) { + uint32_t val = texture_kind->As()->Value()->ValueAs(); + return b.Constant(val == uint32_t(res_type)); + } + return b.Equal(texture_kind, u32(res_type))->Result(); + } + + // Generates the code to access the item at `idx` from the resource table. Does not do any + // validation of the types, just gets the resource. For samplers, will handle the + // `get_sampler_index_from_metadata` flag. + ir::Instruction* GenGetResource(ir::Value* idx, const type::Type* binding_type) { + if (config->get_sampler_index_from_metadata && IsSampler(binding_type)) { + // Get the sampler index from the metadata entry (high 16 bits) + // TODO(crbug.com/503755700): Optimize to avoid loading twice from + // storage_buffer[idx]. + auto* metadata_val = GetTypeId(idx); + auto* sampler_index = b.ShiftRight(metadata_val, u32(16)); + idx = sampler_index->Result(); + } + + auto var = var_for_type.Get(binding_type); + TINT_IR_ASSERT(ir, var); + + const core::type::Pointer* ptr_ty = ty.ptr(handle, binding_type, read); + auto* access = b.Access(ptr_ty, (*var)->Result(), idx); + return b.Load(access); + } + + ir::Value* GetDefaultForIndex(ResourceType resource_type) { + auto idx_iter = resource_type_to_default_idx.find(resource_type); + TINT_IR_ASSERT(ir, idx_iter != resource_type_to_default_idx.end()); + + // Get the table's API size, which is stored at index 0 in the metadata buffer + auto* len_access = b.Access(ty.ptr(), storage_buffer, 0_u); + ir::Value* num_elements = b.Load(len_access)->Result(); + + return b.Add(u32(idx_iter->second), num_elements)->Result(); + } + + void GenSampledGetResource(ir::CoreBuiltinCall* call, const CallArgs& args) { + // we can get the texture, or the sampler, or both. + TINT_IR_ASSERT(ir, args.texture.has_value() || args.sampler.has_value()); + + bool is_sampler_comparison_call = + call->Func() == core::BuiltinFn::kTextureSampleCompare || + call->Func() == core::BuiltinFn::kTextureSampleCompareLevel || + call->Func() == core::BuiltinFn::kTextureGatherCompare; + + // Pre-calculate the operand indices. We know we have at least one of these, so if the + // needed optional isn't set we can always use the other optional to calculate the index. + size_t texture_operand_idx = + args.texture.has_value() ? args.texture->operand_idx : args.sampler->operand_idx - 1; + size_t sampler_operand_idx = + args.sampler.has_value() ? args.sampler->operand_idx : args.texture->operand_idx + 1; + + core::ir::Value* texture_kind = GetKind(call, args.texture, is_sampler_comparison_call, + texture_operand_idx, "texture_kind"); + core::ir::Value* sampler_kind = GetKind(call, args.sampler, is_sampler_comparison_call, + sampler_operand_idx, "sampler_kind"); + + // Only need to validate the texture/sampler if we aren't don't a comparison sampler. + if (is_sampler_comparison_call) { + return; + } + + // If we know the sampler type at compile time, we can skip all the if checks below if + // we know it isn't filtering. + if (sampler_kind->Is() && + sampler_kind->As()->Value()->ValueAs() == + uint32_t(ResourceType::kSampler_non_filtering)) { + return; + } + + ir::Value* tex = call->Args()[texture_operand_idx]; + + // Validate that the sampler/texture pair work together + b.InsertBefore(call, [&] { + core::ir::Value* samp_res = nullptr; + if (!sampler_kind->Is()) { + core::ir::Instruction* sampler_compare = + b.Equal(sampler_kind, u32(ResourceType::kSampler_filtering)); + + // Returns `true` if we need to replace the sampler with a default non_filtering + // sampler + core::ir::If* samp_if = b.If(sampler_compare); + samp_res = b.InstructionResult(ty.bool_()); + ir.SetName(samp_res, "use_sampler"); + samp_if->SetResult(samp_res->As()); + + // If the sampler is filtering + b.Append(samp_if->True(), [&] { + ir::Value* tex_res = ConstructTextureFilterableCheck(tex->Type(), texture_kind); + b.ExitIf(samp_if, tex_res); + }); + + // Sampler != filtering, so use_sampler is true + b.Append(samp_if->False(), [&] { b.ExitIf(samp_if, true); }); + } else { + samp_res = ConstructTextureFilterableCheck(tex->Type(), texture_kind); + } + + const core::type::Type* result_ty = call->Result()->Type(); + + // Branch over if we can use the sampler or not, the `if` returns the result of the + // `call` we're attempting to make + core::ir::If* check = b.If(samp_res); + check->SetResult(call->DetachResult()); + + auto CloneCall = [&] { + core::ir::Call* c = b.Call(result_ty, call->Func()); + for (ir::Value* arg : call->Args()) { + c->AppendArg(arg); + } + return c; + }; + + // Sampler and texture matched, just call + b.Append(check->True(), [&] { + core::ir::Call* c = CloneCall(); + b.ExitIf(check, c); + }); + + // Sampler and texture mismatch, pull a default sampler and use that + b.Append(check->False(), [&] { + ir::Value* final_index = GetDefaultForIndex(ResourceType::kSampler_non_filtering); + ir::Instruction* sampler = GenGetResource(final_index, ty.sampler()); + + // Create the call and swap in the new sampler + core::ir::Call* c = CloneCall(); + c->SetOperand(sampler_operand_idx, sampler->Result()); + + b.ExitIf(check, c); + }); + }); + call->Destroy(); + } + + void InjectRootBlockEntries() { + b.Append(ir.root_block, [&] { + // Any needed vars to hold the resource table bindings (e.g. in SPIR-V this turns in a + // var per type. + var_for_type = helper->GenerateVars(b, config->resource_table_binding, + config->default_binding_type_order); + + // Create the metadata table for resource type information + auto* str = ty.Struct(ir.symbols.New("tint_resource_table_metadata_struct"), + Vector{ + {ir.symbols.New("array_length"), ty.u32()}, + {ir.symbols.New("bindings"), ty.array()}, + }); + auto* sb_ty = ty.ptr(storage, str, read); + + storage_buffer = b.Var("tint_resource_table_metadata", sb_ty); + storage_buffer->SetBindingPoint(config->storage_buffer_binding.group, + config->storage_buffer_binding.binding); + }); + TINT_IR_ASSERT(ir, storage_buffer != nullptr); + } + + void CalculateDefaultBindingIndices() { + for (size_t i = 0; i < config->default_binding_type_order.size(); ++i) { + auto res_ty = static_cast(config->default_binding_type_order[i]); + resource_type_to_default_idx.insert({res_ty, static_cast(i)}); + } } }; @@ -219,13 +631,15 @@ struct State { ResourceTableHelper::~ResourceTableHelper() = default; Result ResourceTable(core::ir::Module& ir, - const ResourceTableConfig& config, + const std::optional& config, ResourceTableHelper* helper) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, {}, "core.ResourceTable")); + AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + }, + "before core.ResourceTable"); - State{config, ir, helper}.Process(); - - return Success; + return State{config, ir, helper}.Process(); } } // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.h index 712ac8cc5..61b9f2843 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table.h @@ -65,7 +65,7 @@ class ResourceTableHelper { /// @param helper the resource binding helper /// @returns success or failure Result ResourceTable(core::ir::Module& module, - const ResourceTableConfig& config, + const std::optional& config, ResourceTableHelper* helper); } // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.cc index 477c6bd11..916670541 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.cc @@ -28,21 +28,18 @@ #include "src/tint/lang/core/ir/transform/resource_table_helper.h" #include +#include #include #include #include "src/tint/lang/core/ir/core_builtin_call.h" +#include "src/tint/lang/core/ir/var.h" #include "src/tint/lang/core/type/resource_type.h" namespace tint::core::ir::transform { -std::optional GenerateResourceTableConfig(Module& mod) { - ResourceTableConfig cfg{ - .resource_table_binding = BindingPoint{.group = 43, .binding = 51}, - .storage_buffer_binding = BindingPoint{.group = 42, .binding = 52}, - .default_binding_type_order = {}, - }; - +std::optional GenerateResourceTableConfig(Module& mod, + bool treat_samplers_as_filtering) { std::vector default_binding_type_order; for (auto* inst : mod.Instructions()) { @@ -57,19 +54,75 @@ std::optional GenerateResourceTableConfig(Module& mod) { } auto exp = call->ExplicitTemplateParams(); TINT_IR_ASSERT(mod, exp.Length() == 1); + TINT_IR_ASSERT(mod, std::holds_alternative(exp[0])); - default_binding_type_order.push_back(type::TypeToResourceType(exp[0])); + std::vector converts = + ConvertsFrom(std::get(exp[0])); + // The converts from only contains values for the filterable types, for + // the others it returns empty so we need to add the ResourceType for + // that specific type. + if (converts.empty()) { + default_binding_type_order.push_back( + TypeToResourceType(std::get(exp[0]))); + } else { + for (ResourceType from : converts) { + default_binding_type_order.push_back(from); + } + } } - // If we found any resource uses, then we can just return an empty config. + // If we didn't find any resource uses, then we can just return an empty config. if (default_binding_type_order.empty()) { return {}; } + std::unordered_map binding_to_resource_type; + for (auto* inst : *(mod.root_block)) { + auto* var = inst->As(); + if (!var) { + continue; + } + + const type::Type* ty = var->Result()->Type()->UnwrapPtr(); + if (!ty->Is() && !ty->Is()) { + continue; + } + + BindingPoint bp = var->BindingPoint().value(); + + if (ty->Is() && !ty->As()->IsComparison() && + treat_samplers_as_filtering) { + // Push both them to defaults because we need to fall back to the non-filtering version + default_binding_type_order.push_back(ResourceType::kSampler_filtering); + default_binding_type_order.push_back(ResourceType::kSampler_non_filtering); + + binding_to_resource_type.emplace(bp, ResourceType::kSampler_filtering); + continue; + } + + binding_to_resource_type.emplace(bp, DefaultResourceTypeFor(ty)); + + std::vector converts = ConvertsFrom(ty); + // The converts from only contains values for the filterable types, for + // the others it returns empty so we need to add the ResourceType for + // that specific type. + if (converts.empty()) { + default_binding_type_order.push_back(TypeToResourceType(ty)); + } else { + for (ResourceType from : converts) { + default_binding_type_order.push_back(from); + } + } + } + // Sort so we get stable generated results std::sort(default_binding_type_order.begin(), default_binding_type_order.end()); - cfg.default_binding_type_order = std::move(default_binding_type_order); - return cfg; + return ResourceTableConfig{ + .resource_table_binding = BindingPoint{.group = 43, .binding = 51}, + .storage_buffer_binding = BindingPoint{.group = 42, .binding = 52}, + .default_binding_type_order = std::move(default_binding_type_order), + .binding_to_resource_type = std::move(binding_to_resource_type), + }; } } // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.h index 7a7ab2bd9..1cf4c4158 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/resource_table_helper.h @@ -35,8 +35,9 @@ namespace tint::core::ir::transform { -std::optional GenerateResourceTableConfig(tint::core::ir::Module& mod); - +std::optional GenerateResourceTableConfig( + tint::core::ir::Module& mod, + bool treat_samplers_as_filtering); } #endif // SRC_TINT_LANG_CORE_IR_TRANSFORM_RESOURCE_TABLE_HELPER_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.cc index b753e122b..fb318dd43 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.cc @@ -70,6 +70,7 @@ struct State { Vector vector_stores; Vector subgroup_matrix_calls; Vector texture_calls; + Vector buffer_view_calls; if (config.use_integer_range_analysis) { integer_range_analysis.emplace(&ir); @@ -113,6 +114,13 @@ struct State { call->Func() == core::BuiltinFn::kSubgroupMatrixStore) { subgroup_matrix_calls.Push(call); } + // Check if this is a buffer view builtin that needs to be clamped. + if (call->Func() == core::BuiltinFn::kBufferView || + call->Func() == core::BuiltinFn::kBufferArrayView) { + if (ShouldClamp(call->Args()[0])) { + buffer_view_calls.Push(call); + } + } }); } @@ -154,6 +162,13 @@ struct State { PredicateSubgroupMatrixCall(call); }); } + + // Clamp offset and size for buffer[Array]View calls. + for (auto* call : buffer_view_calls) { + b.InsertBefore(call, [&] { // + ClampBufferViewArgs(call); + }); + } } /// Check if clamping should be applied to a particular value. @@ -272,12 +287,12 @@ struct State { void ClampAccessIndices(ir::Access* access) { auto* type = access->Object()->Type()->UnwrapPtr(); auto indices = access->Indices(); - for (size_t i = 0; i < indices.Length(); i++) { + for (size_t i = 0; i < indices.size(); i++) { auto* idx = indices[i]; auto* const_idx = idx->As(); // Determine the limit of the type being indexed into. - auto limit = tint::Switch( + auto maxAllowedIndex = tint::Switch( type, // [&](const type::Vector* vec) -> ir::Value* { return b.Constant(u32(vec->Width() - 1u)); @@ -308,13 +323,14 @@ struct State { } // Use the `arrayLength` builtin to get the limit of a runtime-sized array. + // Subtract 1 to get the max allowed index. (Array size is always at least 1.) auto* length = b.Call(ty.u32(), core::BuiltinFn::kArrayLength, object); return b.Subtract(length, b.Constant(1_u))->Result(); }); // If there's a dynamic limit that needs enforced, clamp the index operand. - if (limit) { - ClampOperand(access, ir::Access::kIndicesOperandOffset + i, limit); + if (maxAllowedIndex) { + ClampOperand(access, ir::Access::kIndicesOperandOffset + i, maxAllowedIndex); } // Get the type that this index produces. @@ -361,10 +377,18 @@ struct State { b.Min(CastToU32(args[idx]), limit)->Result()); }; + // Helper for clamping the sample index. + auto clamp_sample_index = [&](uint32_t idx) { + auto* num_samples = b.Call(ty.u32(), core::BuiltinFn::kTextureNumSamples, args[0]); + auto* limit = b.Subtract(num_samples, 1_u); + call->SetOperand(CoreBuiltinCall::kArgsOperandOffset + idx, + b.Min(CastToU32(args[idx]), limit)->Result()); + }; + // Select which arguments to clamp based on the function overload. switch (call->Func()) { case core::BuiltinFn::kTextureDimensions: { - if (args.Length() > 1) { + if (args.size() > 1) { clamp_level(1u); } break; @@ -377,14 +401,10 @@ struct State { if (texture->IsAnyOf()) { clamp_level(next_arg++); } - clamp_coords(1u); // Must run after clamp_level - break; - } - case core::BuiltinFn::kTextureStore: { - clamp_coords(1u); - if (type::IsTextureArray(texture->Dim())) { - clamp_array_index(2u); + if (texture->IsAnyOf()) { + clamp_sample_index(next_arg++); } + clamp_coords(1u); // Must run after clamp_level break; } default: @@ -401,20 +421,38 @@ struct State { // Extract the arguments from the call. auto* arr = args[0]; auto* offset = args[1]; - Value* col_major = nullptr; + bool col_major = true; Value* stride = nullptr; uint32_t stride_index = 0; const type::SubgroupMatrix* matrix_ty = nullptr; if (call->Func() == BuiltinFn::kSubgroupMatrixLoad) { - col_major = args[2]; - stride = args[3]; - stride_index = 3; + if (call->ExplicitTemplateParams().Length() == 2) { + TINT_IR_ASSERT( + ir, std::holds_alternative(call->ExplicitTemplateParams()[1])); + col_major = std::get(call->ExplicitTemplateParams()[1]) == + core::Majorness::kColMajor; + stride = args[2]; + stride_index = 2; + } else { + col_major = args[2]->As()->Value()->ValueAs(); + stride = args[3]; + stride_index = 3; + } matrix_ty = call->Result()->Type()->As(); } else if (call->Func() == BuiltinFn::kSubgroupMatrixStore) { matrix_ty = args[2]->Type()->As(); - col_major = args[3]; - stride = args[4]; - stride_index = 4; + if (call->ExplicitTemplateParams().Length() == 1) { + TINT_IR_ASSERT( + ir, std::holds_alternative(call->ExplicitTemplateParams()[0])); + col_major = std::get(call->ExplicitTemplateParams()[0]) == + core::Majorness::kColMajor; + stride = args[3]; + stride_index = 3; + } else { + col_major = args[3]->As()->Value()->ValueAs(); + stride = args[4]; + stride_index = 4; + } } else { TINT_IR_UNREACHABLE(ir); } @@ -423,7 +461,7 @@ struct State { // determine the number of elements in memory that will be accessed. uint32_t min_stride = 0; uint32_t major_dim = 0; - if (col_major->As()->Value()->ValueAs()) { + if (col_major) { min_stride = matrix_ty->Rows(); major_dim = matrix_ty->Columns(); } else { @@ -518,6 +556,134 @@ struct State { }); } + void ClampBufferViewArgs(ir::CoreBuiltinCall* call) { + // bufferView %ptr, %offset, [%length] + // bufferArrayView %ptr, %offset, %size, [%length] + + // Determine the minimum size need for the return type. + // If the type does not have a fixed footprint (i.e. contains a runtime-sized array) then we + // want to ensure at least one element of it is included. + auto* store_ty = call->Result()->Type()->UnwrapPtrOrRef(); + uint32_t ty_required_size = 0; + uint32_t ty_stride = 0; + uint32_t ty_offset = 0; + if (store_ty->HasFixedFootprint()) { + ty_required_size = store_ty->Size(); + } else { + if (auto* str_ty = store_ty->As()) { + auto last = str_ty->Members().Back(); + auto last_ty = last->Type(); + TINT_IR_ASSERT(ir, last_ty->Is()); + ty_offset = last->Offset(); + ty_stride = last_ty->As()->ImplicitStride(); + ty_required_size = ty_offset + ty_stride; + } else { + TINT_IR_ASSERT(ir, store_ty->Is()); + ty_stride = store_ty->As()->ImplicitStride(); + ty_required_size = ty_stride; + } + } + + b.InsertBefore(call, [&] { + uint32_t required_size = 0; + auto* offset = call->Args()[1]; + auto* size = call->Func() == BuiltinFn::kBufferArrayView ? call->Args()[2] : nullptr; + // If the length arg exists, use it. Otherwise, insert a bufferLength call. + Value* length = nullptr; + if (call->Func() == BuiltinFn::kBufferView && call->Args().size() > 2) { + length = call->Args()[2]; + } else if (call->Func() == BuiltinFn::kBufferArrayView && call->Args().size() > 3) { + length = call->Args()[3]; + } else { + length = b.Call(ty.u32(), BuiltinFn::kBufferLength, call->Args()[0])->Result(); + } + + // Handle constant arguments. + bool const_offset = false; + bool const_size = false; + if (auto* offset_cnst = offset->As()) { + uint32_t offset_val = offset_cnst->Value()->ValueAs(); + required_size += offset_val; + const_offset = true; + if (!offset->Type()->Is()) { + offset = b.Constant(u32(offset_val)); + } + } + if (size) { + if (auto* size_cnst = size->As()) { + auto size_val = size_cnst->Value()->ValueAs(); + required_size += size_val; + const_size = true; + if (!size->Type()->Is()) { + size = b.Constant(u32(size_val)); + } + } + } else { + required_size += ty_required_size; + } + + Value* total_required_size = + required_size == 0 ? nullptr : b.Constant(u32(required_size)); + if (!const_offset) { + offset = b.InsertBitcastIfNeeded(ty.u32(), offset); + if (total_required_size) { + total_required_size = + b.Call(ty.u32(), BuiltinFn::kAddSat, total_required_size, offset)->Result(); + } else { + TINT_IR_ASSERT(ir, size && !const_size); + total_required_size = offset; + } + } + if (size && !const_size) { + // Use the larger of the size arg or the type required size. + // PropagateBufferSizes performed a round down on the argument which may have + // resulted in a 0 length array. + size = b.InsertBitcastIfNeeded(ty.u32(), size); + size = b.Call(ty.u32(), BuiltinFn::kMax, size, b.Constant(u32(ty_required_size))) + ->Result(); + if (total_required_size) { + total_required_size = + b.Call(ty.u32(), BuiltinFn::kAddSat, total_required_size, size)->Result(); + } else { + // offset must have been 0. + TINT_IR_ASSERT(ir, offset && const_offset); + total_required_size = size; + } + } + + // Now check if length < total_required_size + // If true, this is an invalid memory view and we will try to patch it safely. + // If false, use the args as is. + // + // In the bad case we have the liberty to generate anything safe. + // So just use offset = 0 and size = required_size. + // This will generate at least one element in the runtime array. + // This should be always safe as minimum binding sizes ought to be based on these values + // via inspection. + // TODO(github.com/gpuweb/issues/5410): If this resolution changes we may need to + // introduce predication instead of clamping. + if (length->Is() && total_required_size->Is()) { + bool cmp = length->As()->Value()->ValueAs() < + total_required_size->As()->Value()->ValueAs(); + call->SetArg(1, (cmp ? b.Constant(0_u) : offset)); + if (size) { + call->SetArg(2, (cmp ? b.Constant(u32(ty_required_size)) : size)); + } + return; + } + + auto* len_less_than = b.LessThan(length, total_required_size); + auto* offset_select = b.Call(ty.u32(), BuiltinFn::kSelect, offset, 0_u, len_less_than); + call->SetArg(1, offset_select->Result()); + Instruction* size_select = nullptr; + if (size) { + size_select = b.Call(ty.u32(), BuiltinFn::kSelect, size, + b.Constant(u32(ty_required_size)), len_less_than); + call->SetArg(2, size_select->Result()); + } + }); + } + // Returns the root Var for `value` by walking up the chain of instructions, // or nullptr if none is found. Var* RootVarFor(Value* value) { @@ -541,6 +707,14 @@ struct State { result = var; return nullptr; // Done }, + [&](CoreBuiltinCall* call) { + Value* call_value = nullptr; + if (call->Func() == BuiltinFn::kBufferView || + call->Func() == BuiltinFn::kBufferArrayView) { + call_value = call->Args()[0]; + } + return call_value; + }, TINT_ICE_ON_NO_MATCH); }, [&](FunctionParam*) { @@ -568,7 +742,7 @@ struct State { } // namespace Result Robustness(Module& ir, const RobustnessConfig& config) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kRobustnessCapabilities, "core.Robustness")); + AssertValid(ir, kRobustnessCapabilities, "before core.Robustness"); State{config, ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.h index 16d4d73dd..6342e9a55 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/robustness.h @@ -32,7 +32,7 @@ #include "src/tint/api/common/binding_point.h" #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -44,8 +44,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kRobustnessCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// Configuration options that control when to clamp accesses. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.cc index d5dadf0dd..70650f0ec 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.cc @@ -61,7 +61,8 @@ struct State { std::unique_ptr backend{}; /// Process the module. - void Process() { + /// @returns Success if all of the sub-tasks succeed, otherwise propagates the failure reason + Result Process() { // Collect all structures before the transform has run, so that we can strip their shader IO // attributes later. Vector structures_to_strip; @@ -80,7 +81,7 @@ struct State { continue; } - ProcessEntryPoint(func, make_backend_state(ir, func)); + TINT_CHECK_RESULT(ProcessEntryPoint(func, make_backend_state(ir, func))); } // Remove IO attributes from all structure members that had them prior to this transform. @@ -90,12 +91,15 @@ struct State { const_cast(member)->ResetAttributes(); } } + + return Success; } /// Process an entry point. /// @param f the original entry point function /// @param bs the backend state object - void ProcessEntryPoint(Function* f, std::unique_ptr bs) { + /// @returns Success if all of the sub-tasks succeed, otherwise propagates the failure reason + Result ProcessEntryPoint(Function* f, std::unique_ptr bs) { TINT_SCOPED_ASSIGNMENT(ep, f); backend = std::move(bs); TINT_DEFER(backend = nullptr); @@ -107,6 +111,7 @@ struct State { // Add an output for the vertex point size if needed. std::optional vertex_point_size_index; if (ep->IsVertex() && backend->NeedsVertexPointSize()) { + ir.properties.Add(core::ir::Property::kAllowPointSizeBuiltin); vertex_point_size_index = backend->AddOutput(ir.symbols.New("vertex_point_size"), ty.f32(), core::IOAttributes{ @@ -114,12 +119,12 @@ struct State { }); } - auto new_params = backend->FinalizeInputs(); - auto* new_ret_ty = backend->FinalizeOutputs(); + TINT_CHECK_RESULT_UNWRAP(new_params, backend->FinalizeInputs()); + TINT_CHECK_RESULT_UNWRAP(new_ret_ty, backend->FinalizeOutputs()); // Skip entry points with no new inputs or outputs. if (!backend->HasInputs() && !backend->HasOutputs()) { - return; + return Success; } // Rename the old function and remove its pipeline stage, workgroup size and subgroup size, @@ -157,6 +162,8 @@ struct State { // Return the new result. wrapper.Return(wrapper_ep, backend->MakeReturnValue(wrapper)); + + return Success; } /// Gather the shader inputs. @@ -257,6 +264,23 @@ struct State { } // namespace +bool ShaderIOBackendState::HasBuiltinInput(core::BuiltinValue builtin) const { + return inputs.Any([builtin](auto& struct_mem_desc) { // + return struct_mem_desc.attributes.builtin == builtin; + }); +} + +uint32_t ShaderIOBackendState::RequireBuiltinInput(core::BuiltinValue builtin, + const core::type::Type* type, + std::string_view name) { + for (uint32_t i = 0; i < inputs.Length(); i++) { + if (inputs[i].attributes.builtin == builtin) { + return i; + } + } + return AddInput(ir.symbols.New(name), type, core::IOAttributes{.builtin = builtin}); +} + core::ir::Value* ShaderIOBackendState::PolyfillWorkgroupIndex(Builder& builder, uint32_t workgroup_id_index, uint32_t num_workgroups_index) { @@ -317,8 +341,9 @@ core::ir::Value* ShaderIOBackendState::PolyfillGlobalInvocationIndex( return tint_global_invocation_index; } -void RunShaderIOBase(Module& module, std::function make_backend_state) { - State{make_backend_state, module}.Process(); +Result RunShaderIOBase(Module& module, + std::function make_backend_state) { + return State{make_backend_state, module}.Process(); } ShaderIOBackendState::~ShaderIOBackendState() = default; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.h index 8ddad91e9..b568d261c 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/shader_io.h @@ -33,6 +33,7 @@ #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/type/manager.h" +#include "src/tint/utils/result.h" namespace tint::core::ir::transform { @@ -73,12 +74,13 @@ struct ShaderIOBackendState { bool HasOutputs() const { return !outputs.IsEmpty(); } /// Finalize the shader inputs and create any state needed for the new entry point function. - /// @returns the list of function parameters for the new entry point - virtual Vector FinalizeInputs() = 0; + /// @returns the list of function parameters for the new entry point on success, otherwise a + /// failure reason + virtual Result> FinalizeInputs() = 0; /// Finalize the shader outputs and create state needed for the new entry point function. - /// @returns the return type for the new entry point - virtual const type::Type* FinalizeOutputs() = 0; + /// @returns the return type for the new entry point on success, otherwise a failure reason + virtual Result FinalizeOutputs() = 0; /// Get the value of the input at index @p idx /// @param builder the IR builder for new instructions @@ -103,6 +105,15 @@ struct ShaderIOBackendState { /// @returns true if a vertex point size builtin should be added virtual bool NeedsVertexPointSize() const { return false; } + /// @returns true if there is an input with builtin @p builtin + bool HasBuiltinInput(core::BuiltinValue builtin) const; + + /// Get the index of the input with builtin attribute @p builtin or create one if needed. + /// The @p type and @p name parameters are used to create the builtin if it was not found. + uint32_t RequireBuiltinInput(core::BuiltinValue builtin, + const core::type::Type* type, + std::string_view name); + /// Creates the polyfilled workgroup_index builtin value. /// Each backend is responsible for tracking the indices of workgroup_id and num_workgroups /// builtin values (and ensuring they are available in the module). @@ -156,7 +167,9 @@ using MakeBackendStateFunc = std::unique_ptr(Module&, Func /// @param module the module to transform /// @param make_backend_state a function that creates a backend state object -void RunShaderIOBase(Module& module, std::function make_backend_state); +/// @returns Success if all sub-tasks succeed, otherwise propagates the failure reason +Result RunShaderIOBase(Module& module, + std::function make_backend_state); } // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.cc index a8f94e9c7..4d95d606c 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.cc @@ -27,6 +27,8 @@ #include "src/tint/lang/core/ir/transform/signed_integer_polyfill.h" +#include + #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/core_binary.h" #include "src/tint/lang/core/ir/module.h" @@ -48,16 +50,16 @@ struct State { /// Process the module. void Process() { - Vector signed_int_negate_worklist; - Vector signed_integer_arithmetic_worklist; - Vector signed_integer_leftshift_worklist; + std::vector> worklist; + worklist.reserve(128); + for (auto* inst : ir.Instructions()) { if (auto* unary = inst->As()) { auto op = unary->Op(); auto* type = unary->Val()->Type(); if (cfg.signed_negation && op == core::UnaryOp::kNegation && type->IsSignedIntegerScalarOrVector()) { - signed_int_negate_worklist.Push(unary); + worklist.push_back([this, unary] { SignedIntegerNegation(unary); }); } } else if (auto* binary = inst->As()) { auto op = binary->Op(); @@ -66,23 +68,16 @@ struct State { (op == core::BinaryOp::kAdd || op == core::BinaryOp::kMultiply || op == core::BinaryOp::kSubtract) && lhs_type->IsSignedIntegerScalarOrVector()) { - signed_integer_arithmetic_worklist.Push(binary); + worklist.push_back([this, binary] { SignedIntegerArithmetic(binary); }); } else if (cfg.signed_shiftleft && op == core::BinaryOp::kShiftLeft && lhs_type->IsSignedIntegerScalarOrVector()) { - signed_integer_leftshift_worklist.Push(binary); + worklist.push_back([this, binary] { SignedIntegerShiftLeft(binary); }); } } } - // Replace the instructions that we found. - for (auto* signed_int_negate : signed_int_negate_worklist) { - SignedIntegerNegation(signed_int_negate); - } - for (auto* signed_arith : signed_integer_arithmetic_worklist) { - SignedIntegerArithmetic(signed_arith); - } - for (auto* signed_shift_left : signed_integer_leftshift_worklist) { - SignedIntegerShiftLeft(signed_shift_left); + for (auto& cb : worklist) { + cb(); } } @@ -145,23 +140,12 @@ struct State { Result SignedIntegerPolyfill(core::ir::Module& ir, const SignedIntegerPolyfillConfig& cfg) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllow8BitIntegers, - core::ir::Capability::kAllow64BitIntegers, - core::ir::Capability::kAllowPointSizeBuiltin, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowAnyLetType, - core::ir::Capability::kMslAllowEntryPointInterface, - core::ir::Capability::kAllowModuleScopeLets, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - }, - "ir.SignedIntegerPolyfill")); + AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kAllow16BitIntegers, + core::ir::Capability::kAllow64BitIntegers, + }, + "before ir.SignedIntegerPolyfill"); State{ir, cfg}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.h index 2cd5f0fb1..6f5249fd5 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/signed_integer_polyfill.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_SIGNED_INTEGER_POLYFILL_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.cc index 0cc86fd9a..56606b65c 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.cc @@ -105,10 +105,13 @@ Result Run(ir::Module& ir, std::string_view entry_point_name) { } // namespace Result SingleEntryPoint(Module& ir, std::string_view entry_point_name) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kSingleEntryPointCapabilities, "core.SingleEntryPoint")); + AssertValid(ir, kSingleEntryPointCapabilities, "before core.SingleEntryPoint"); - return Run(ir, entry_point_name); + TINT_CHECK_RESULT(Run(ir, entry_point_name)); + + ir.properties.Remove(Property::kAllowMultipleEntryPoints); + + return Success; } } // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.h index 3c1497767..156d8546b 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/single_entry_point.h @@ -40,9 +40,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kSingleEntryPointCapabilities{ - Capability::kAllowMultipleEntryPoints, - Capability::kAllowOverrides, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// Strip a module down to a single entry point, removing any unused functions and module-scope diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.cc index 0a4730839..70dbb8d57 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.cc @@ -352,7 +352,7 @@ struct State { indices.Push(b.Constant(0_u)); } - for (size_t i = 0, n = access->Indices().Length(); i < n; i++) { + for (size_t i = 0, n = access->Indices().size(); i < n; i++) { auto* idx = access->Indices()[i]; if (auto* mat = NeedsDecomposing(current_type)) { @@ -448,7 +448,7 @@ struct State { } // namespace Result Std140(Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kStd140Capabilities, "core.Std140")); + AssertValid(ir, kStd140Capabilities, "before core.Std140"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.h index 40636788d..ffa24d5c4 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/std140.h @@ -40,11 +40,6 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kStd140Capabilities{ - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, core::ir::Capability::kLoosenValidationForShaderIO, }; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.cc index 84aca74fa..1c06353a9 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.cc @@ -88,6 +88,11 @@ struct State { vars_with_value_array_count.Push(var); } } + if (auto* buf = var->Result()->Type()->UnwrapPtr()->As()) { + if (buf->Count()->Is()) { + vars_with_value_array_count.Push(var); + } + } } else { // Gather all the non-var instructions which we'll remove to_remove.Push(inst); @@ -164,6 +169,32 @@ struct State { // Workgroup size and subgroup size MUST be evaluated prior to 'propagate' because workgroup // size and subgroup size parameters are not proper usages. for (auto func : ir.functions) { + for (auto* param : func->Params()) { + if (auto* old_ptr = param->Type()->As()) { + TINT_CHECK_RESULT_UNWRAP(new_ptr, ReplaceOverrideType(old_ptr)); + if (new_ptr) { + param->SetType(new_ptr); + auto usages = param->UsagesSorted(); + while (!usages.IsEmpty()) { + auto use = usages.Pop(); + auto* inst = use.instruction; + // This is an edge case where we have to specifically verify bounds + // access for these new arrays for all usages. + if (NeedsEval(inst)) { + TINT_CHECK_RESULT(eval::Eval(b, inst)); + } + if (!inst->Is()) { + continue; + } + + inst->Result()->SetType(new_ptr); + for (auto& u : inst->Result()->UsagesSorted()) { + usages.Push(u); + } + } + } + } + } if (!func->IsCompute()) { continue; } @@ -171,9 +202,23 @@ struct State { auto wgs = func->WorkgroupSize(); TINT_IR_ASSERT(ir, wgs.has_value()); + uint64_t total_size = 1; + constexpr uint64_t kMaxGridSize = 0xffffffff; + std::array new_wg{}; for (size_t i = 0; i < 3; ++i) { TINT_CHECK_RESULT_UNWRAP(new_value, CalculateOverride(wgs.value()[i])); + + if (new_value->Value()->ValueAs() <= 0) { + return diag::Failure("@workgroup_size values must be greater than 0"); + } + + total_size *= new_value->Value()->ValueAs(); + if (total_size > kMaxGridSize) { + return diag::Failure("workgroup grid size cannot exceed " + + std::to_string(kMaxGridSize)); + } + new_wg[i] = new_value; } func->SetWorkgroupSize(new_wg); @@ -185,40 +230,14 @@ struct State { } } - // Replace array types MUST be evaluate prior to 'propagate' because array count values are - // not proper usages. + // Replace array/buffer types MUST be evaluate prior to 'propagate' because array count + // values are not proper usages. for (auto var : vars_with_value_array_count) { auto* old_ptr = var->Result()->Type()->As(); TINT_IR_ASSERT(ir, old_ptr); - auto* old_ty = old_ptr->UnwrapPtr()->As(); - auto* cnt = old_ty->Count()->As(); - TINT_IR_ASSERT(ir, cnt); - - TINT_CHECK_RESULT_UNWRAP(new_value, CalculateOverride(cnt->value)); - - // Pipeline creation error for zero or negative sized array. This is important as we do - // not check constant evaluation access against zero size. - int64_t cnt_size_check = new_value->Value()->ValueAs(); - if (cnt_size_check < 1) { - diag::Diagnostic error = MakeError(ir.SourceOf(cnt->value)); - error << "array count (" << cnt_size_check << ") must be greater than 0"; - return diag::Failure(error); - } - - uint32_t num_elements = new_value->Value()->ValueAs(); - uint64_t new_ary_size = uint64_t{num_elements} * old_ty->ImplicitStride(); - if (new_ary_size > std::numeric_limits::max()) { - diag::Diagnostic error = MakeError(ir.SourceOf(cnt->value)); - error << "array size (" << new_ary_size << ") is too large"; - return diag::Failure(error); - } - - auto* new_cnt = ty.Get(num_elements); - auto* new_ty = ty.Get(old_ty->ElemType(), new_cnt, - static_cast(new_ary_size)); - - auto* new_ptr = ty.ptr(old_ptr->AddressSpace(), new_ty, old_ptr->Access()); + TINT_CHECK_RESULT_UNWRAP(new_ptr, ReplaceOverrideType(old_ptr)); + TINT_IR_ASSERT(ir, new_ptr); var->Result()->SetType(new_ptr); // The `Var` type needs to propagate to certain usages. @@ -264,6 +283,55 @@ struct State { return Success; } + diag::Result ReplaceOverrideType( + const core::type::Pointer* old_ptr) { + const core::ir::type::ValueArrayCount* cnt = nullptr; + auto* old_ary_ty = old_ptr->UnwrapPtr()->As(); + if (old_ary_ty) { + cnt = old_ary_ty->Count()->As(); + } + auto* old_buf_ty = old_ptr->UnwrapPtr()->As(); + if (old_buf_ty) { + cnt = old_buf_ty->Count()->As(); + } + if (!cnt) { + return nullptr; + } + + TINT_CHECK_RESULT_UNWRAP(new_value, CalculateOverride(cnt->value)); + + // Pipeline creation error for zero or negative sized array. This is important as we do + // not check constant evaluation access against zero size. + int64_t cnt_size_check = new_value->Value()->ValueAs(); + if (cnt_size_check < 1) { + diag::Diagnostic error = MakeError(ir.SourceOf(cnt->value)); + error << "array count (" << cnt_size_check << ") must be greater than 0"; + return diag::Failure(error); + } + + uint32_t num_elements = new_value->Value()->ValueAs(); + auto* new_cnt = ty.Get(num_elements); + + const core::type::Type* new_ty = nullptr; + if (old_ary_ty) { + uint64_t new_ary_size = uint64_t{num_elements} * old_ary_ty->ImplicitStride(); + if (new_ary_size > std::numeric_limits::max()) { + diag::Diagnostic error = MakeError(ir.SourceOf(cnt->value)); + error << "array size (" << new_ary_size << ") is too large"; + return diag::Failure(error); + } + + new_ty = ty.Get(old_ary_ty->ElemType(), new_cnt, + static_cast(new_ary_size)); + } else { + TINT_IR_ASSERT(ir, old_buf_ty); + new_ty = ty.Get(new_cnt); + } + + auto* new_ptr = ty.ptr(old_ptr->AddressSpace(), new_ty, old_ptr->Access()); + return new_ptr; + } + diag::Result EvalConstExprIf() { Vector ordered_constexpr_if; core::ir::Traverse(ir.root_block, [&ordered_constexpr_if](ConstExprIf* inst) { @@ -345,7 +413,6 @@ struct State { bool NeedsEval(core::ir::Instruction* inst) { return tint::Switch( // inst, // - [&](core::ir::Bitcast*) { return true; }, // [&](core::ir::Access*) { return true; }, // [&](core::ir::Construct*) { return true; }, // [&](core::ir::Convert*) { return true; }, // @@ -372,8 +439,7 @@ struct State { } // namespace Result SubstituteOverrides(Module& ir, const SubstituteOverridesConfig& cfg) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, kSubstituteOverridesCapabilities, "core.SubstituteOverrides")); + AssertValid(ir, kSubstituteOverridesCapabilities, "before core.SubstituteOverrides"); { auto result = State{ir, cfg}.Process(); if (result != Success) { @@ -383,7 +449,11 @@ Result SubstituteOverrides(Module& ir, const SubstituteOverridesCon // TODO(crbug.com/382300469): This function should take in a constant module but it does not due // to missing constant functions. - return tint::core::ir::ValidateConstParam(ir); + TINT_CHECK_RESULT(tint::core::ir::ValidateConstParam(ir)); + + ir.properties.Remove(Property::kAllowOverrides); + + return Success; } } // namespace tint::core::ir::transform diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.h index dc13e6103..6265b9a4f 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/substitute_overrides.h @@ -32,7 +32,7 @@ #include "src/tint/api/common/substitute_overrides_config.h" #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -44,8 +44,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kSubstituteOverridesCapabilities{ - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, }; /// Substitute overrides to their constant values. diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.cc index 3278e1b75..5e465b799 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.cc @@ -135,6 +135,12 @@ struct State { pending_access = Instruction::Access::kLoad; } inst = MaybePutInLet(inst, accesses); + } else if (inst->Results().Length() == 1 && inst->Result()->NumUsages() > 1) { + // Avoid inlining non-trivial expressions with no side effects when they are used + // multiple times. + if (!inst->IsAnyOf()) { + inst = PutInLet(inst->Result()); + } } } } @@ -230,7 +236,7 @@ struct State { } // namespace Result ValueToLet(Module& ir, const ValueToLetConfig& cfg) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kValueToLetCapabilities, "core.ValueToLet")); + AssertValid(ir, kValueToLetCapabilities, "before core.ValueToLet"); State{ir, cfg}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.h index f815e06a2..6a0a4aba2 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/value_to_let.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_CORE_IR_TRANSFORM_VALUE_TO_LET_H_ #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" // Forward declarations. @@ -41,18 +41,8 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kValueToLetCapabilities{ - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, core::ir::Capability::kAllow64BitIntegers, - - core::ir::Capability::kAllowPointSizeBuiltin, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowAnyLetType, - core::ir::Capability::kMslAllowEntryPointInterface, - core::ir::Capability::kAllowModuleScopeLets, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, core::ir::Capability::kLoosenValidationForShaderIO, }; diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.cc index 3eb085ea6..ae46d617e 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.cc @@ -94,8 +94,8 @@ struct State { } // namespace Result VectorizeScalarMatrixConstructors(Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kVectorizeScalarMatrixConstructorsCapabilities, - "core.VectorizeScalarMatrixConstructors")); + AssertValid(ir, kVectorizeScalarMatrixConstructorsCapabilities, + "before core.VectorizeScalarMatrixConstructors"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.h index 30f25558a..4b2d20504 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/vectorize_scalar_matrix_constructors.h @@ -40,12 +40,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const core::ir::Capabilities kVectorizeScalarMatrixConstructorsCapabilities{ - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowHandleVarsWithoutBindings, - core::ir::Capability::kAllowClipDistancesOnF32ScalarAndVector, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, + core::ir::Capability::kAllow16BitIntegers, }; /// VectorizeScalarMatrixConstructors is a transform that replaces construct instructions that diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/vertex_pulling.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/vertex_pulling.cc index 0592c64b1..eb41e654a 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/vertex_pulling.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/vertex_pulling.cc @@ -686,7 +686,7 @@ struct State { } // namespace Result VertexPulling(core::ir::Module& ir, const VertexPullingConfig& config) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kVertexPullingCapabilities, "core.VertexPulling")); + AssertValid(ir, kVertexPullingCapabilities, "before core.VertexPulling"); State{config, ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc b/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc index 4ffd6f41d..76ba08771 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.cc @@ -84,6 +84,10 @@ struct State { const type::Type* store_type = nullptr; /// The list of index operands to get to the element. Vector indices; + /// The bufferView call (nullptr unless var's type is a buffer). + /// This gets set just before generating stores so all the bufferView calls go at the shared + /// count. + CoreBuiltinCall* buffer_view = nullptr; }; /// StoreList is a list of `Store` descriptors. @@ -140,6 +144,23 @@ struct State { for (auto count : sorted_iteration_counts) { auto element_stores = stores.Get(count); TINT_IR_ASSERT(ir, count); + for (auto& store : *element_stores) { + // For buffers, add a buffer view call to an appropriate array (u32/f16) + // of count elements. + if (auto* buf_ty = + store.var->Result()->Type()->UnwrapPtr()->As()) { + auto buf_count = buf_ty->ConstantCount().value(); + const core::type::Type* ele_ty = ty.u32(); + if (buf_count % 4 != 0) { + ele_ty = ty.f16(); + } + auto* arr_ty = ty.array(ele_ty, count); + store.buffer_view = + b.CallExplicit(ty.ptr(workgroup, arr_ty), core::BuiltinFn::kBufferView, + Vector{arr_ty}, store.var, 0_u); + } + } + // No loop is required if we have at least as many invocations than counts. if (count <= wgsize) { // Make the first |count| invocations in the group perform the arrayed stores. @@ -205,6 +226,28 @@ struct State { new_indices.Push(member->Index()); PrepareStores(var, member->Type(), iteration_count, new_indices, stores); } + }, + [&](const type::Buffer* buf) { + // TODO(crbug.com/tint/495142520): This could be more efficient than just choosing + // between an array of one type. Instead we could pick a size a larger size and add + // a small tail as a separate set of stores. + TINT_IR_ASSERT(ir, buf->ConstantCount()); + auto len = buf->ConstantCount().value(); + // This assumes 8-bit types are not encountered in workgroup. + bool four_byte = len % 4 == 0; + if (four_byte) { + len /= 4; + } else { + TINT_IR_ASSERT(ir, len % 2 == 0); + len /= 2; + } + auto new_indices = indices; + new_indices.Push(ArrayIndex{len}); + const core::type::Type* ele_ty = ty.u32(); + if (!four_byte) { + ele_ty = ty.f16(); + } + PrepareStores(var, ele_ty, len * iteration_count, new_indices, stores); }, // TINT_ICE_ON_NO_MATCH); } @@ -244,7 +287,8 @@ struct State { /// @param total_count the total number of elements that will be zeroed /// @param linear_index the linear index of the single element that will be zeroed void GenerateStore(const Store& store, uint32_t total_count, Value* linear_index) { - auto* to = store.var->Result(); + // If a bufferView call exists for `store`, use it over the var. + auto* to = store.buffer_view ? store.buffer_view->Result() : store.var->Result(); if (!store.indices.IsEmpty()) { // Build the access indices to get to the target element. // We walk backwards along the index list so that adjacent invocation store to @@ -289,7 +333,7 @@ struct State { /// @param type the type to inspect /// @returns true if a variable with store type @p ty can be efficiently zeroed bool CanTriviallyZero(const core::type::Type* type) { - if (type->IsAnyOf()) { + if (type->IsAnyOf()) { return false; } if (auto* str = type->As()) { @@ -306,8 +350,7 @@ struct State { } // namespace Result ZeroInitWorkgroupMemory(Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kZeroInitWorkgroupMemoryCapabilities, - "core.ZeroInitWorkgroupMemory")); + AssertValid(ir, kZeroInitWorkgroupMemoryCapabilities, "before core.ZeroInitWorkgroupMemory"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.h b/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.h index 895235c91..afde25ce9 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/transform/zero_init_workgroup_memory.h @@ -40,9 +40,7 @@ namespace tint::core::ir::transform { /// The capabilities that the transform can support. const Capabilities kZeroInitWorkgroupMemoryCapabilities{ - Capability::kAllowDuplicateBindings, - Capability::kAllowNonCoreTypes, - Capability::kAllow8BitIntegers, + Capability::kAllow16BitIntegers, }; /// ZeroInitWorkgroupMemory is a transform that injects code at the top of each entry point to diff --git a/3rdparty/dawn/src/tint/lang/core/ir/validator.cc b/3rdparty/dawn/src/tint/lang/core/ir/validator.cc index 8712e6c5a..d60cf9e10 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/validator.cc +++ b/3rdparty/dawn/src/tint/lang/core/ir/validator.cc @@ -27,5367 +27,129 @@ #include "src/tint/lang/core/ir/validator.h" -#include -#include -#include -#include -#include -#include - -#include "src/tint/lang/core/intrinsic/table.h" -#include "src/tint/lang/core/ir/access.h" -#include "src/tint/lang/core/ir/binary.h" -#include "src/tint/lang/core/ir/bitcast.h" -#include "src/tint/lang/core/ir/block_param.h" -#include "src/tint/lang/core/ir/break_if.h" -#include "src/tint/lang/core/ir/constant.h" -#include "src/tint/lang/core/ir/constexpr_if.h" -#include "src/tint/lang/core/ir/construct.h" -#include "src/tint/lang/core/ir/continue.h" -#include "src/tint/lang/core/ir/control_instruction.h" -#include "src/tint/lang/core/ir/convert.h" -#include "src/tint/lang/core/ir/core_builtin_call.h" -#include "src/tint/lang/core/ir/disassembler.h" -#include "src/tint/lang/core/ir/discard.h" -#include "src/tint/lang/core/ir/exit_if.h" -#include "src/tint/lang/core/ir/exit_loop.h" -#include "src/tint/lang/core/ir/exit_switch.h" -#include "src/tint/lang/core/ir/function.h" -#include "src/tint/lang/core/ir/function_param.h" -#include "src/tint/lang/core/ir/if.h" -#include "src/tint/lang/core/ir/instruction.h" -#include "src/tint/lang/core/ir/instruction_result.h" -#include "src/tint/lang/core/ir/let.h" -#include "src/tint/lang/core/ir/load.h" -#include "src/tint/lang/core/ir/load_vector_element.h" -#include "src/tint/lang/core/ir/loop.h" -#include "src/tint/lang/core/ir/member_builtin_call.h" -#include "src/tint/lang/core/ir/multi_in_block.h" -#include "src/tint/lang/core/ir/next_iteration.h" -#include "src/tint/lang/core/ir/override.h" -#include "src/tint/lang/core/ir/phony.h" -#include "src/tint/lang/core/ir/referenced_functions.h" -#include "src/tint/lang/core/ir/referenced_module_vars.h" -#include "src/tint/lang/core/ir/return.h" -#include "src/tint/lang/core/ir/store.h" -#include "src/tint/lang/core/ir/store_vector_element.h" -#include "src/tint/lang/core/ir/switch.h" -#include "src/tint/lang/core/ir/swizzle.h" -#include "src/tint/lang/core/ir/terminate_invocation.h" -#include "src/tint/lang/core/ir/type/array_count.h" -#include "src/tint/lang/core/ir/unary.h" -#include "src/tint/lang/core/ir/unreachable.h" -#include "src/tint/lang/core/ir/unused.h" -#include "src/tint/lang/core/ir/user_call.h" -#include "src/tint/lang/core/ir/var.h" -#include "src/tint/lang/core/type/array.h" -#include "src/tint/lang/core/type/array_count.h" -#include "src/tint/lang/core/type/binding_array.h" -#include "src/tint/lang/core/type/bool.h" -#include "src/tint/lang/core/type/f16.h" -#include "src/tint/lang/core/type/f32.h" -#include "src/tint/lang/core/type/function.h" -#include "src/tint/lang/core/type/i32.h" -#include "src/tint/lang/core/type/i8.h" -#include "src/tint/lang/core/type/matrix.h" -#include "src/tint/lang/core/type/memory_view.h" -#include "src/tint/lang/core/type/pointer.h" -#include "src/tint/lang/core/type/reference.h" -#include "src/tint/lang/core/type/sampled_texture.h" -#include "src/tint/lang/core/type/storage_texture.h" -#include "src/tint/lang/core/type/type.h" -#include "src/tint/lang/core/type/u16.h" -#include "src/tint/lang/core/type/u32.h" -#include "src/tint/lang/core/type/u64.h" -#include "src/tint/lang/core/type/u8.h" -#include "src/tint/lang/core/type/vector.h" -#include "src/tint/lang/core/type/void.h" -#include "src/tint/utils/containers/hashset.h" -#include "src/tint/utils/containers/predicates.h" -#include "src/tint/utils/containers/reverse.h" -#include "src/tint/utils/containers/transform.h" -#include "src/tint/utils/diagnostic/diagnostic.h" -#include "src/tint/utils/ice/ice.h" -#include "src/tint/utils/internal_limits.h" -#include "src/tint/utils/macros/defer.h" -#include "src/tint/utils/result.h" -#include "src/tint/utils/rtti/castable.h" -#include "src/tint/utils/rtti/switch.h" -#include "src/tint/utils/text/styled_text.h" -#include "src/tint/utils/text/text_style.h" - -/// If set to 1 then the Tint will dump the IR when validating. -#define TINT_DUMP_IR_WHEN_VALIDATING 0 -#if TINT_DUMP_IR_WHEN_VALIDATING +#if TINT_ENABLE_IR_DUMPING #include - -#include "src/tint/utils/text/styled_text_printer.h" #endif +#include "src/tint/lang/core/ir/disassembler.h" +#include "src/tint/lang/core/ir/functional_validator.h" +#include "src/tint/lang/core/ir/structural_validator.h" +#include "src/tint/utils/text/styled_text_printer.h" + using namespace tint::core::fluent_types; // NOLINT namespace tint::core::ir { -struct ValidatedType { - const core::type::Type* ty; - Capabilities caps; -}; - namespace { -/// Prints out the current IR state, iff TINT_DUMP_IR_WHEN_VALIDATING is set. +/// Prints out the current IR state, iff ir.dump_ir_when_validating is set. void DumpIRIfEnabled([[maybe_unused]] const Module& ir, - [[maybe_unused]] const char* msg = "", - [[maybe_unused]] std::string_view timing = "") { -#if TINT_DUMP_IR_WHEN_VALIDATING - auto printer = StyledTextPrinter::Create(stdout); - std::cout << "=========================================================\n"; - std::cout << "== IR dump " << timing << " " << msg << ":\n"; - std::cout << "=========================================================\n"; - printer->Print(Disassembler(ir).Text()); + [[maybe_unused]] const std::string_view msg) { +#if TINT_ENABLE_IR_DUMPING + if (ir.dump_ir_when_validating) { + auto printer = StyledTextPrinter::Create(stdout); + std::cout << "=========================================================\n"; + std::cout << "== IR dump " << msg << ":\n"; + std::cout << "=========================================================\n"; + printer->Print(Disassembler(ir).Text()); + } #endif } -using SupportedStages = tint::EnumSet; - -/// @returns a human-readable string of all the entries in a EnumSet -template -std::string ToString(const EnumSet& values) { - std::stringstream result; - result << "[ "; - bool first = true; - for (auto v : values) { - if (!first) { - result << ", "; - } - first = false; - result << ToString(v); - } - result << " ]"; - return result.str(); -} - -/// @returns the parent block of @p block -const Block* ParentBlockOf(const Block* block) { - if (auto* parent = block->Parent()) { - return parent->Block(); - } - return nullptr; -} - -/// @returns true if @p block directly or transitively holds the instruction @p inst -bool TransitivelyHolds(const Block* block, const Instruction* inst) { - for (auto* b = inst->Block(); b; b = ParentBlockOf(b)) { - if (b == block) { - return true; - } - } - return false; -} - -/// @returns true if @p ty meets the basic function parameter rules (i.e. one of constructible, -/// pointer, handle). -/// -/// Note: Does not handle corner cases like if certain capabilities are -/// enabled. -bool IsValidFunctionParamType(const core::type::Type* ty) { - if (ty->IsConstructible() || ty->IsHandle()) { - return true; - } - - if (auto* ptr = ty->As()) { - return ptr->AddressSpace() != core::AddressSpace::kHandle; - } - return false; -} - -/// @returns true if @p ty is a non-struct and decorated with @builtin(position), or if it is a -/// struct and one of its members is decorated, otherwise false. -/// @param attr attributes attached to data -/// @param ty type of the data being tested -bool IsPositionPresent(const IOAttributes& attr, const core::type::Type* ty) { - if (auto* ty_struct = ty->As()) { - for (const auto* mem : ty_struct->Members()) { - if (mem->Attributes().builtin == BuiltinValue::kPosition) { - return true; - } - } - return false; - } - - return attr.builtin == BuiltinValue::kPosition; -} - -/// Helper that walks the members of a struct, called from WalkTypeAndMembers and its helpers -/// @param ctx a context object to pass to the impl function -/// @param str the struct to walk the members of -/// @param impl an impl function to be run, see WalkTypeAndMembers for details -template -void WalkStructMembers(CTX& ctx, const core::type::Struct* str, IMPL&& impl) { - for (auto* member : str->Members()) { - WalkTypeAndMembers(ctx, member->Type(), member->Attributes(), impl); - } -} - -/// Helper that walks an array's element type, called from WalkTypeAndMembers and its helpers -/// @param ctx a context object to pass to the impl function -/// @param arr the array to walk the element type of -/// @param impl an impl function to be run, see WalkTypeAndMembers for details -template -void WalkArrayElements(CTX& ctx, const core::type::Array* arr, IMPL&& impl) { - tint::Switch( - arr->ElemType(), [&](const core::type::Struct* s) { WalkStructMembers(ctx, s, impl); }, - [&](const core::type::Array* a) { WalkArrayElements(ctx, a, impl); }); -} - -/// Helper for walking a type that maybe a struct, calling an impl function for the type and each of -/// its members. -/// @param ctx a context object to pass to the implementation function -/// @param type the type to walk -/// @param attr the attributes for @p type -/// @param impl a function with the signature `void(const core::type::Type*, const IOAttributes&, -/// CTX&)` that is called for each type. -template -void WalkTypeAndMembers(CTX& ctx, - const core::type::Type* type, - const IOAttributes& attr, - IMPL&& impl) { - impl(ctx, type, attr); - tint::Switch( - type, [&](const core::type::Struct* s) { WalkStructMembers(ctx, s, impl); }, - [&](const core::type::Array* a) { WalkArrayElements(ctx, a, impl); }); -} - -/// @returns true if the type or any contained types are atomic -/// @param ty root of the types to walks -bool ContainsAtomic(const core::type::Type* ty) { - bool found = false; - WalkTypeAndMembers(found, ty, IOAttributes{}, - [&](bool& ctx, const core::type::Type* t, const IOAttributes&) { - if (t != nullptr && t->Is()) { - ctx = true; - } - }); - return found; -} - -/// The IO direction of an operation. -enum class IODirection : uint8_t { kInput, kOutput, kResource }; - -/// @returns a human-readable string for an IODirection -std::string_view ToString(IODirection value) { - switch (value) { - case IODirection::kInput: - return "input"; - case IODirection::kOutput: - return "output"; - case IODirection::kResource: - return "resource"; - } - TINT_ICE() << "Unknown enum passed to ToString(IODirection)"; -} - -IODirection IODirectionFor(AddressSpace address_space) { - switch (address_space) { - case AddressSpace::kIn: - return IODirection::kInput; - case AddressSpace::kOut: - return IODirection::kOutput; - case AddressSpace::kHandle: - return IODirection::kResource; - default: - TINT_ICE() << "Unexpected address_space '" << ToString(address_space) - << "' passed to IODirectionFrom()"; - } -} - -/// The kind of shader IO being validated. -enum class ShaderIOKind : uint8_t { - kInputParam, - kResultValue, - kModuleScopeVar, -}; - -/// @returns text describing the shader IO kind for error logging -std::string ToString(ShaderIOKind value) { - switch (value) { - case ShaderIOKind::kInputParam: - return "input param"; - case ShaderIOKind::kResultValue: - return "return value"; - case ShaderIOKind::kModuleScopeVar: - return "module scope variable"; - } - TINT_ICE() << "Unknown enum passed to ToString(ShaderIOKind)"; -} - -/// How an attribute is being used, a tuple of the shader stage and IO direction -enum class IOAttributeUsage : uint8_t { - kComputeInputUsage, - kComputeOutputUsage, - kComputeResourceUsage, - kFragmentInputUsage, - kFragmentOutputUsage, - kFragmentResourceUsage, - kVertexInputUsage, - kVertexOutputUsage, - kVertexResourceUsage, - kUndefinedUsage, -}; - -/// @returns a human-readable string for an IOAttributeUsage -std::string ToString(IOAttributeUsage value) { - switch (value) { - case IOAttributeUsage::kComputeInputUsage: - return "compute shader input"; - case IOAttributeUsage::kComputeOutputUsage: - return "compute shader output"; - case IOAttributeUsage::kComputeResourceUsage: - return "compute shader resource"; - case IOAttributeUsage::kFragmentInputUsage: - return "fragment shader input"; - case IOAttributeUsage::kFragmentOutputUsage: - return "fragment shader output"; - case IOAttributeUsage::kFragmentResourceUsage: - return "fragment shader resource"; - case IOAttributeUsage::kVertexInputUsage: - return "vertex shader input"; - case IOAttributeUsage::kVertexOutputUsage: - return "vertex shader output"; - case IOAttributeUsage::kVertexResourceUsage: - return "vertex shader resourcee"; - case IOAttributeUsage::kUndefinedUsage: - return "non-entry point usage"; - } - TINT_ICE() << "Unknown enum passed to ToString(IOAttribute)"; -} - -/// @returns the IOAttributeUsage for a given Function::PipelineStage + IODirection tuple -IOAttributeUsage IOAttributeUsageFor(Function::PipelineStage stage, IODirection direction) { - switch (stage) { - case Function::PipelineStage::kCompute: - switch (direction) { - case IODirection::kInput: - return IOAttributeUsage::kComputeInputUsage; - case IODirection::kOutput: - return IOAttributeUsage::kComputeOutputUsage; - case IODirection::kResource: - return IOAttributeUsage::kComputeResourceUsage; - } - case Function::PipelineStage::kFragment: - switch (direction) { - case IODirection::kInput: - return IOAttributeUsage::kFragmentInputUsage; - case IODirection::kOutput: - return IOAttributeUsage::kFragmentOutputUsage; - case IODirection::kResource: - return IOAttributeUsage::kFragmentResourceUsage; - } - case Function::PipelineStage::kVertex: - switch (direction) { - case IODirection::kInput: - return IOAttributeUsage::kVertexInputUsage; - case IODirection::kOutput: - return IOAttributeUsage::kVertexOutputUsage; - case IODirection::kResource: - return IOAttributeUsage::kVertexResourceUsage; - } - case Function::PipelineStage::kUndefined: - return IOAttributeUsage::kUndefinedUsage; - } - TINT_ICE() << "Unknown IOAttribute usage " << ToString(direction) << " for a " - << ToString(stage) << " entry point"; -} - -/// @returns the Function::PipelineStage for an IOAttributeUsage -[[maybe_unused]] Function::PipelineStage PipelineStageFor(IOAttributeUsage usage) { - switch (usage) { - case IOAttributeUsage::kComputeInputUsage: - case IOAttributeUsage::kComputeOutputUsage: - case IOAttributeUsage::kComputeResourceUsage: - return Function::PipelineStage::kCompute; - case IOAttributeUsage::kFragmentInputUsage: - case IOAttributeUsage::kFragmentOutputUsage: - case IOAttributeUsage::kFragmentResourceUsage: - return Function::PipelineStage::kFragment; - case IOAttributeUsage::kVertexInputUsage: - case IOAttributeUsage::kVertexOutputUsage: - case IOAttributeUsage::kVertexResourceUsage: - return Function::PipelineStage::kVertex; - case IOAttributeUsage::kUndefinedUsage: - return Function::PipelineStage::kUndefined; - } - TINT_ICE() << "Unknown IOAttribute usage " << ToString(usage); -} - -/// @returns the IODirection for an IOAttributeUsage -[[maybe_unused]] IODirection IODirectionFor(IOAttributeUsage usage) { - switch (usage) { - case IOAttributeUsage::kComputeInputUsage: - case IOAttributeUsage::kFragmentInputUsage: - case IOAttributeUsage::kVertexInputUsage: - return IODirection::kInput; - case IOAttributeUsage::kComputeOutputUsage: - case IOAttributeUsage::kFragmentOutputUsage: - case IOAttributeUsage::kVertexOutputUsage: - return IODirection::kOutput; - case IOAttributeUsage::kComputeResourceUsage: - case IOAttributeUsage::kFragmentResourceUsage: - case IOAttributeUsage::kVertexResourceUsage: - case IOAttributeUsage::kUndefinedUsage: - return IODirection::kResource; // Technically it could also be a kInput or kOutput, but - // no validation depends on differentiate between these - // cases currently. - } - TINT_ICE() << "Unknown IOAttribute usage " << ToString(usage); -} - -/// A BuiltInChecker is the interface used to check that a usage of a builtin attribute meets the -/// basic spec rules, i.e. correct shader stage, data type, and IO direction. -/// It does not test more sophisticated rules like location and builtins being mutually exclusive or -/// that the correct capabilities are enabled. -struct BuiltInChecker { - /// What combination of stage and IO direction is this builtin legal for - EnumSet valid_usages; - - /// What values for depth_mode are valid for this builtin. - /// Currently, kUndefined is the only valid option for non-frag_depth - EnumSet valid_depth_modes = - EnumSet{BuiltinDepthMode::kUndefined}; - - /// Implements logic for checking if the given type is valid or not. Is not a data entry (i.e. a - /// type or set of types), because types are part of the IR module and created at runtime. - using TypeCheckFn = bool(const core::type::Type* type, const Capabilities& cap); - - /// @see #TypeCheckFn - TypeCheckFn* const type_check; - - /// Message for logging if the type check fails. Cannot be easily generated at runtime, because - /// the type check is a function, not just a data entry. - const char* type_error; -}; - -constexpr BuiltInChecker kPointSizeChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be a f32", -}; - -/// returns true if the number of elements in @p ty is valid for use in clip_distances without -/// Capability::kAllowClipDistancesOnF32. -constexpr auto ClipDistancesElementsCheck = [](const core::type::Type* ty) -> bool { - const auto elems = ty->Elements(); - return elems.type && elems.type->Is() && elems.count <= 8; -}; - -constexpr BuiltInChecker kClipDistancesChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is() && ClipDistancesElementsCheck(ty); - }, - .type_error = "must be an array, where N <= 8", -}; - -constexpr BuiltInChecker kClipDistancesAllowF32ScalarAndVectorChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ((ty->Is() || ty->Is()) && - ClipDistancesElementsCheck(ty)) || - ty->Is(); - }, - .type_error = "must be a f32 or either a vecN or an array, where N <= 8", -}; - -constexpr BuiltInChecker kCullDistanceChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is() && ty->DeepestElement()->Is(); - }, - .type_error = "must be an array of f32", -}; - -constexpr BuiltInChecker kFragDepthChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentOutputUsage}, - .valid_depth_modes = - EnumSet{BuiltinDepthMode::kUndefined, BuiltinDepthMode::kAny, - BuiltinDepthMode::kGreater, BuiltinDepthMode::kLess}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be a f32", -}; - -constexpr BuiltInChecker kFrontFacingChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be a bool", -}; - -constexpr BuiltInChecker kGlobalInvocationIdChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsUnsignedIntegerVector() && ty->Elements().count == 3; - }, - .type_error = "must be an vec3", -}; - -constexpr BuiltInChecker kInstanceIndexChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kLocalInvocationIdChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsUnsignedIntegerVector() && ty->Elements().count == 3; - }, - .type_error = "must be an vec3", -}; - -constexpr BuiltInChecker kLocalInvocationIndexChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kNumSubgroupsChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kNumWorkgroupsChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsUnsignedIntegerVector() && ty->Elements().count == 3; - }, - .type_error = "must be an vec3", -}; - -constexpr BuiltInChecker kPositionChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage, - IOAttributeUsage::kFragmentInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsFloatVector() && ty->Elements().count == 4; - }, - .type_error = "must be an vec4", -}; - -constexpr BuiltInChecker kSampleIndexChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kSampleMaskChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage, - IOAttributeUsage::kFragmentOutputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kSubgroupIdChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kSubgroupInvocationIdChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage, - IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kSubgroupSizeChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage, - IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kVertexIndexChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kVertexInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kWorkgroupIdChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kComputeInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsUnsignedIntegerVector() && ty->Elements().count == 3; - }, - .type_error = "must be an vec3", -}; - -constexpr BuiltInChecker kPrimitiveIndexChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->Is(); - }, - .type_error = "must be an u32", -}; - -constexpr BuiltInChecker kBarycentricCoordChecker{ - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsFloatVector() && ty->Elements().count == 3; - }, - .type_error = "must be an vec3", -}; - -/// @returns an appropriate BuiltInCheck for @p builtin, ICEs when one isn't defined -const BuiltInChecker& BuiltinCheckerFor(BuiltinValue builtin, const Capabilities& capabilities) { - switch (builtin) { - case BuiltinValue::kPointSize: - return kPointSizeChecker; - case BuiltinValue::kClipDistances: - if (capabilities.Contains(Capability::kAllowClipDistancesOnF32ScalarAndVector)) { - return kClipDistancesAllowF32ScalarAndVectorChecker; - } - return kClipDistancesChecker; - case BuiltinValue::kCullDistance: - return kCullDistanceChecker; - case BuiltinValue::kFragDepth: - return kFragDepthChecker; - case BuiltinValue::kFrontFacing: - return kFrontFacingChecker; - case BuiltinValue::kGlobalInvocationId: - return kGlobalInvocationIdChecker; - case BuiltinValue::kInstanceIndex: - return kInstanceIndexChecker; - case BuiltinValue::kLocalInvocationId: - return kLocalInvocationIdChecker; - case BuiltinValue::kLocalInvocationIndex: - case BuiltinValue::kGlobalInvocationIndex: - case BuiltinValue::kWorkgroupIndex: - return kLocalInvocationIndexChecker; - case BuiltinValue::kNumSubgroups: - return kNumSubgroupsChecker; - case BuiltinValue::kNumWorkgroups: - return kNumWorkgroupsChecker; - case BuiltinValue::kPosition: - return kPositionChecker; - case BuiltinValue::kSampleIndex: - return kSampleIndexChecker; - case BuiltinValue::kSampleMask: - return kSampleMaskChecker; - case BuiltinValue::kSubgroupId: - return kSubgroupIdChecker; - case BuiltinValue::kSubgroupInvocationId: - return kSubgroupInvocationIdChecker; - case BuiltinValue::kSubgroupSize: - return kSubgroupSizeChecker; - case BuiltinValue::kVertexIndex: - return kVertexIndexChecker; - case BuiltinValue::kWorkgroupId: - return kWorkgroupIdChecker; - case BuiltinValue::kPrimitiveIndex: - return kPrimitiveIndexChecker; - case BuiltinValue::kBarycentricCoord: - return kBarycentricCoordChecker; - default: - TINT_ICE() << builtin << " is does not have a checker defined for it"; - } -} - -/// IOAttributeChecker is the interface used to check that a usage of an IO attribute -/// meets the spec rules for a given context. -struct IOAttributeChecker { - /// What kinda of IO attribute is being checked - IOAttributeKind kind; - - /// What combination of stage and IO direction is this attribute legal for. - EnumSet valid_usages; - - /// What type of shader IO values is this attribute legal for. - EnumSet valid_io_kinds; - - /// Implements the validation logic for a specific attribute. - using CheckFn = Result(const core::type::Type* ty, - const IOAttributes& attr, - const Capabilities& cap, - IOAttributeUsage usage); - - /// The validation function. - CheckFn* const check; - - /// Implements logic for checking if the given type is valid or not. Is not a data entry (i.e. a - /// type or set of types), because types are part of the IR module and created at runtime. - using TypeCheckFn = bool(const core::type::Type* type, const Capabilities& cap); - - /// @see #TypeCheckFn - TypeCheckFn* const type_check; - - /// Message for logging if the type check fails. Cannot be easily generated at runtime, because - /// the type check is a function, not just a data entry. - const char* type_error; -}; - -constexpr IOAttributeChecker kInvariantChecker{ - .kind = IOAttributeKind::kInvariant, - .valid_usages = EnumSet{IOAttributeUsage::kVertexOutputUsage, - IOAttributeUsage::kFragmentInputUsage}, - .valid_io_kinds = EnumSet{ShaderIOKind::kInputParam, ShaderIOKind::kResultValue, - ShaderIOKind::kModuleScopeVar}, - .check = [](const core::type::Type*, - const IOAttributes& attr, - const Capabilities&, - IOAttributeUsage) -> Result { - if (attr.builtin != BuiltinValue::kPosition) { - return {"invariant can only decorate a value if it is also decorated with position"}; - } - return Success; - }, - .type_check = kPositionChecker.type_check, - .type_error = kPositionChecker.type_error, -}; - -constexpr IOAttributeChecker kBuiltinChecker{ - .kind = IOAttributeKind::kBuiltin, - .valid_usages = - EnumSet{ - IOAttributeUsage::kComputeInputUsage, - IOAttributeUsage::kComputeOutputUsage, - IOAttributeUsage::kFragmentInputUsage, - IOAttributeUsage::kFragmentOutputUsage, - IOAttributeUsage::kVertexInputUsage, - IOAttributeUsage::kVertexOutputUsage, - }, - .valid_io_kinds = EnumSet{ShaderIOKind::kInputParam, ShaderIOKind::kResultValue, - ShaderIOKind::kModuleScopeVar}, - .check = [](const core::type::Type* ty, - const IOAttributes& attr, - const Capabilities& cap, - IOAttributeUsage usage) -> Result { - if (!attr.builtin.has_value()) { - return Success; - } - - const auto builtin = attr.builtin.value(); - const auto& checker = BuiltinCheckerFor(builtin, cap); - if (usage != IOAttributeUsage::kUndefinedUsage && !checker.valid_usages.Contains(usage)) { - std::stringstream msg; - msg << ToString(builtin) << " cannot be used on a " << ToString(usage) << ". "; - if (checker.valid_usages.Size() == 1) { - const auto v = *checker.valid_usages.begin(); - msg << "It can only be used on a " << ToString(v) << "."; - } else { - msg << "It can only be used on one of " << ToString(checker.valid_usages); - } - return msg.str(); - } - - if (!checker.type_check(ty, cap)) { - std::stringstream msg; - msg << ToString(builtin) << " " << checker.type_error; - return msg.str(); - } - - const auto depth_mode = attr.depth_mode.value_or(BuiltinDepthMode::kUndefined); - if (!checker.valid_depth_modes.Contains(depth_mode)) { - std::stringstream msg; - msg << ToString(builtin) << " cannot have a depth mode of " << ToString(depth_mode) - << ". "; - if (checker.valid_depth_modes.Size() == 1) { - const auto v = *checker.valid_depth_modes.begin(); - msg << "It can only be " << ToString(v) << "."; - } else { - msg << "It must be one of " << ToString(checker.valid_depth_modes); - } - return msg.str(); - } - - if (builtin == BuiltinValue::kPointSize && - !cap.Contains(Capability::kAllowPointSizeBuiltin)) { - return std::string{"use of point_size builtin requires kAllowPointSizeBuiltin"}; - } - - return Success; - }, - .type_check = [](const core::type::Type*, const Capabilities&) -> bool { return true; }, - .type_error = nullptr, -}; - -constexpr IOAttributeChecker kColorChecker{ - .kind = IOAttributeKind::kColor, - .valid_usages = EnumSet{IOAttributeUsage::kFragmentInputUsage}, - .valid_io_kinds = - EnumSet{ShaderIOKind::kInputParam, ShaderIOKind::kModuleScopeVar}, - .check = [](const core::type::Type*, const IOAttributes&, const Capabilities&, IOAttributeUsage) - -> Result { return Success; }, - .type_check = [](const core::type::Type* ty, const Capabilities&) -> bool { - return ty->IsNumericScalarOrVector(); - }, - .type_error = "must be a scalar or vector", -}; - -constexpr IOAttributeChecker kInputAttachmentIndexChecker{ - .kind = IOAttributeKind::kInputAttachmentIndex, - .valid_usages = EnumSet{IOAttributeUsage::kFragmentResourceUsage}, - .valid_io_kinds = EnumSet{ShaderIOKind::kModuleScopeVar}, - .check = [](const core::type::Type*, const IOAttributes&, const Capabilities&, IOAttributeUsage) - -> Result { return Success; }, - .type_check = [](const core::type::Type* ty, const Capabilities& cap) -> bool { - return cap.Contains(Capability::kAllowAnyInputAttachmentIndexType) || - ty->Is(); - }, - .type_error = "must be an input_attachment", -}; - -constexpr IOAttributeChecker kDepthModeChecker{ - .kind = IOAttributeKind::kDepthMode, - .valid_usages = kBuiltinChecker.valid_usages, - .valid_io_kinds = kBuiltinChecker.valid_io_kinds, - // kBuiltInChecker does the checking of the depth_mode value for the specific builtin. - .check = [](const core::type::Type*, - const IOAttributes& attr, - const Capabilities&, - IOAttributeUsage) -> Result { - if (!attr.builtin.has_value()) { - return {"cannot have a depth_mode without a builtin"}; - } - return Success; - }, - .type_check = [](const core::type::Type*, const Capabilities&) -> bool { return true; }, - .type_error = nullptr, -}; - -// kBlendSrcChecker, kLocationChecker, kInterpolationChecker, and kBindingPointChecker are -// intentionally not implemented - -/// @returns all the appropriate IOAttributeCheckers for @p attr -Vector IOAttributeCheckersFor(const IOAttributes& attr, - bool skip_builtin) { - Vector checkers{}; - if (attr.invariant) { - checkers.Push(&kInvariantChecker); - } - if (!skip_builtin && attr.builtin.has_value()) { - checkers.Push(&kBuiltinChecker); - } - if (attr.color.has_value()) { - checkers.Push(&kColorChecker); - } - if (attr.input_attachment_index.has_value()) { - checkers.Push(&kInputAttachmentIndexChecker); - } - if (attr.depth_mode.has_value()) { - checkers.Push(&kDepthModeChecker); - } - - // attr.blend_src, attr.location, attr.interpolation, and attr.binding_point are intentionally - // skipped, because their rules are not amenable to implementation via IOAttributeChecker. - return checkers; -} - -/// Annotations that can be associated with a value that are used for shader IO, -/// e.g. binding_points, @location, being in workgroup address space, etc. -/// These are a subset of IOAttributes. -enum class IOAnnotation : uint8_t { - /// @group + @binding - kBindingPoint, - /// @location - kLocation, - /// @builtin(...) - kBuiltin, - /// Pointer to Workgroup address space - kWorkgroup, - /// @color - kColor, -}; - -/// @returns text describing the annotation for error logging -std::string ToString(IOAnnotation value) { - switch (value) { - case IOAnnotation::kBindingPoint: - return "@group + @binding"; - case IOAnnotation::kLocation: - return "@location"; - case IOAnnotation::kBuiltin: - return "built-in"; - case IOAnnotation::kWorkgroup: - return ""; - case IOAnnotation::kColor: - return "@color"; - } - TINT_ICE() << "Unknown enum passed to ToString(IOAnnotation)"; -} - -/// Adds appropriate entries to annotations, based on what values are present in attributes -/// @param annotations the set to updated -/// @param attr the attributes to be examined -/// @returns Success if none of the values being added where already present, otherwise returns the -/// first non-unique value as a Failure -Result AddIOAnnotationsFromIOAttributes( - EnumSet& annotations, - const IOAttributes& attr) { - if (attr.location.has_value()) { - if (annotations.Contains(IOAnnotation::kLocation)) { - return IOAnnotation::kLocation; - } - annotations.Add(IOAnnotation::kLocation); - } - - if (attr.builtin.has_value()) { - if (annotations.Contains(IOAnnotation::kBuiltin)) { - return IOAnnotation::kBuiltin; - } - annotations.Add(IOAnnotation::kBuiltin); - } - - if (attr.color.has_value()) { - if (annotations.Contains(IOAnnotation::kColor)) { - return IOAnnotation::kColor; - } - annotations.Add(IOAnnotation::kColor); - } - - return Success; -} - -/// State for validating blend_src attributes shared across multiple passes within the same entry -/// point. -struct BlendSrcContext { - Function::PipelineStage stage; - Hashmap locations; - Hashset blend_srcs; - const core::type::Type* blend_src_type = nullptr; - IODirection dir; -}; - -/// State for validating IO attributes that needs to shared across impl invocations within the same -/// entry point. -struct IOAttributeContext { - Hashmap input_builtins; - Hashmap output_builtins; -}; - /// The core IR validator. class Validator { public: /// Create a core validator /// @param mod the module to be validated /// @param capabilities the optional capabilities that are allowed - explicit Validator(const Module& mod, Capabilities capabilities); + explicit Validator(const Module& mod, Capabilities capabilities = {}) + : mod_(mod), capabilities_(capabilities) {} /// Destructor - ~Validator(); + ~Validator() = default; /// Runs the validator over the module provided during construction /// @returns success or failure - Result Run(); + + Result Run() { + validator::Structural s(mod_, diagnostics_, capabilities_); + s.Validate(); + + // Only run the functional validation if we are structurally valid + if (!diagnostics_.ContainsErrors()) { + validator::Functional f(mod_, diagnostics_, validator::Functional::ErrorSource::kIr); + f.Validate(); + } + + if (diagnostics_.ContainsErrors()) { + const StyledText disassembly = ir::Disassembler(mod_).Text(); + diagnostics_.AddNote(Source{}) << "# Disassembly\n" << disassembly; + return Failure{diagnostics_.Str()}; + } + return Success; + } private: - /// Runs validation to confirm the structural soundness of the module. - /// Also runs any validation that is not dependent on the entire module being - /// sound and sets up data structures for later checks. - void RunStructuralSoundnessChecks(); - - /// Checks that there is no direct or indirect recursion. - /// Depends on CheckStructuralSoundness() having previously been run. - void CheckForRecursion(); - - /// Checks that there are no orphaned instructions - /// Depends on CheckStructuralSoundness() having previously been run - void CheckForOrphanedInstructions(); - - /// Checks that entry points do not use instructions that are not supported by their stage. - /// Depends on CheckStructuralSoundness() having previously been run - void CheckStageRestrictedInstructions(); - - /// @returns the IR disassembly, performing a disassemble if this is the first call. - ir::Disassembler& Disassemble(); - - /// Adds an error for the @p inst and highlights the instruction in the disassembly - /// @param inst the instruction - /// @returns the diagnostic - diag::Diagnostic& AddError(const Instruction* inst); - - /// Adds an error for the @p inst operand at @p idx and highlights the operand in the - /// disassembly - /// @param inst the instruction - /// @param idx the operand index - /// @returns the diagnostic - diag::Diagnostic& AddError(const Instruction* inst, size_t idx); - - /// Adds an error for the @p inst result at @p idx and highlgihts the result in the disassembly - /// @param inst the instruction - /// @param idx the result index - /// @returns the diagnostic - diag::Diagnostic& AddResultError(const Instruction* inst, size_t idx); - - /// Adds an error for the @p block and highlights the block header in the disassembly - /// @param blk the block - /// @returns the diagnostic - diag::Diagnostic& AddError(const Block* blk); - - /// Adds an error for the @p param and highlights the parameter in the disassembly - /// @param param the parameter - /// @returns the diagnostic - diag::Diagnostic& AddError(const BlockParam* param); - - /// Adds an error for the @p func and highlights the function in the disassembly - /// @param func the function - /// @returns the diagnostic - diag::Diagnostic& AddError(const Function* func); - - /// Adds an error for the @p param and highlights the parameter in the disassembly - /// @param param the parameter - /// @returns the diagnostic - diag::Diagnostic& AddError(const FunctionParam* param); - - /// Adds an error for the castable base @p base and highlights it in the disassembly - /// @param base the declaration to add an error for - /// @returns the diagnostic - diag::Diagnostic& AddError(const CastableBase* base); - - /// Adds an error the @p block and highlights the block header in the disassembly - /// @param src the source lines to highlight - /// @returns the diagnostic - diag::Diagnostic& AddError(Source src); - - /// Adds a note to @p inst and highlights the instruction in the disassembly - /// @param inst the instruction - diag::Diagnostic& AddNote(const Instruction* inst); - - /// Adds a note to @p func and highlights the function in the disassembly - /// @param func the function - diag::Diagnostic& AddNote(const Function* func); - - /// Adds a note to @p inst for operand @p idx and highlights the operand in the disassembly - /// @param inst the instruction - /// @param idx the operand index - diag::Diagnostic& AddOperandNote(const Instruction* inst, size_t idx); - - /// Adds a note to @p inst for result @p idx and highlights the result in the disassembly - /// @param inst the instruction - /// @param idx the result index - diag::Diagnostic& AddResultNote(const Instruction* inst, size_t idx); - - /// Adds a note to @p blk and highlights the block in the disassembly - /// @param blk the block - diag::Diagnostic& AddNote(const Block* blk); - - /// Adds a note to the diagnostics - /// @param src the source lines to highlight - diag::Diagnostic& AddNote(Source src = {}); - - /// Adds a note to the diagnostics highlighting where the value instruction or block is - /// declared, if it has a source location. - /// @param decl the value instruction or block - void AddDeclarationNote(const CastableBase* decl); - - /// Adds a note to the diagnostics highlighting where the block is declared, if it has a source - /// location. - /// @param block the block - void AddDeclarationNote(const Block* block); - - /// Adds a note to the diagnostics highlighting where the block parameter is declared, if it - /// has a source location. - /// @param param the block parameter - void AddDeclarationNote(const BlockParam* param); - - /// Adds a note to the diagnostics highlighting where the function is declared, if it has a - /// source location. - /// @param fn the function - void AddDeclarationNote(const Function* fn); - - /// Adds a note to the diagnostics highlighting where the function parameter is declared, if it - /// has a source location. - /// @param param the function parameter - void AddDeclarationNote(const FunctionParam* param); - - /// Adds a note to the diagnostics highlighting where the instruction is declared, if it has a - /// source location. - /// @param inst the inst - void AddDeclarationNote(const Instruction* inst); - - /// Adds a note to the diagnostics highlighting where instruction result was declared, if it has - /// a source location. - /// @param res the res - void AddDeclarationNote(const InstructionResult* res); - - /// @param decl the type, value, instruction or block to get the name for - /// @returns the styled name for the given value, instruction or block - StyledText NameOf(const CastableBase* decl); - - // @param ty the type to get the name for - /// @returns the styled name for the given type - StyledText NameOf(const core::type::Type* ty); - - /// @param v the value to get the name for - /// @returns the styled name for the given value - StyledText NameOf(const Value* v); - - /// @param inst the instruction to get the name for - /// @returns the styled name for the given instruction - StyledText NameOf(const Instruction* inst); - - /// @param block the block to get the name for - /// @returns the styled name for the given block - StyledText NameOf(const Block* block); - - /// Checks the given result is not null and its type is not null - /// @param inst the instruction - /// @param idx the result index - /// @returns true if the result is not null - bool CheckResult(const Instruction* inst, size_t idx); - - /// Checks the results (and their types) for @p inst are not null. If count is specified then - /// number of results is checked to be exact. - /// @param inst the instruction - /// @param count the number of results to check - /// @returns true if the results count is as expected and none are null - bool CheckResults(const ir::Instruction* inst, std::optional count); - - /// Checks the given operand is not null and its type is not null - /// @param inst the instruction - /// @param idx the operand index - /// @returns true if the operand is not null - bool CheckOperand(const Instruction* inst, size_t idx); - - /// Checks the number of operands provided to @p inst and that none of them are null. Also - /// checks that the types for the operands are not null - /// @param inst the instruction - /// @param min_count the minimum number of operands to expect - /// @param max_count the maximum number of operands to expect, if not set, than only the minimum - /// number is checked. - /// @returns true if the number of operands is in the expected range and none are null - bool CheckOperands(const ir::Instruction* inst, - size_t min_count, - std::optional max_count); - - /// Checks the operands (and their types) for @p inst are not null. If count is specified then - /// number of operands is checked to be exact. - /// @param inst the instruction - /// @param count the number of operands to check - /// @returns true if the operands count is as expected and none are null - bool CheckOperands(const ir::Instruction* inst, std::optional count); - - /// Checks the number of results for @p inst are exactly equal to @p num_results and the number - /// of operands is correctly. Both results and operands are confirmed to be non-null. - /// @param inst the instruction - /// @param num_results expected number of results for the instruction - /// @param min_operands the minimum number of operands to expect - /// @param max_operands the maximum number of operands to expect, if not set, than only the - /// minimum number is checked. - /// @returns true if the result and operand counts are as expected and none are null - bool CheckResultsAndOperandRange(const ir::Instruction* inst, - size_t num_results, - size_t min_operands, - std::optional max_operands); - - /// Checks the number of results and operands for @p inst are exactly equal to num_results - /// and num_operands, respectively, and that none of them are null. - /// @param inst the instruction - /// @param num_results expected number of results for the instruction - /// @param num_operands expected number of operands for the instruction - /// @returns true if the result and operand counts are as expected and none are null - bool CheckResultsAndOperands(const ir::Instruction* inst, - size_t num_results, - size_t num_operands); - - /// Checks that @p type is allowed by the spec, and does not use any types that are prohibited - /// by the target capabilities. - /// @param type the type - /// @param diag a function that creates an error diagnostic for the source of the type - /// @param ignore_caps a set of capabilities to ignore for this check - void CheckType(const core::type::Type* type, - std::function diag, - Capabilities ignore_caps = {}, - Capabilities allow_caps = {}); - - /// Validates the root block - /// @param blk the block - void CheckRootBlock(const Block* blk); - - /// Validates the given instruction is only used in the root block. - /// @param inst the instruction - void CheckOnlyUsedInRootBlock(const Instruction* inst); - - /// Validates the given function - /// @param func the function to validate - void CheckFunction(const Function* func); - - /// Validates the workgroup_size attribute for a given function - /// @param func the function to validate - void CheckWorkgroupSize(const Function* func); - - /// Validates the subgroup_size attribute for a given function - /// @param func the function to validate - void CheckSubgroupSize(const Function* func); - - /// Validates the specific function as a vertex entry point - /// @param ep the function to validate - void CheckPositionPresentForVertexOutput(const Function* ep); - - /// Validates the spec rules for IO attribute usage for a function. - /// @param func the function to validate - void ValidateIOAttributes(const Function* func); - - /// Implementation for validating the spec rules for IO attribute usage. - /// @param ctx context object shared between the multiple invocations of this per entry point - /// @param msg_anchor the object to anchor the error message to - /// @param ty the data type being decorated by the attributes - /// @param attr the attributes to test - /// @param stage the shader stage the builtin is being used - /// @param dir is value being used as an input or an output - /// @param io_kind is the type of shader IO object the attribute is attached to - void ValidateIOAttributesImpl(IOAttributeContext& ctx, - const CastableBase* msg_anchor, - const core::type::Type* ty, - const IOAttributes& attr, - Function::PipelineStage stage, - IODirection dir, - ShaderIOKind io_kind); - - /// Validates that a type is a bool only if it is decorated with @builtin(front_facing). - /// @param msg_anchor where to attach errors to - /// @param attr the IO attributes - /// @param ty the type - /// @param err error message to log when check fails - void CheckFrontFacingIfBool(const CastableBase* msg_anchor, - const IOAttributes& attr, - const core::type::Type* ty, - const std::string& err); - - /// Validates that a type is not a bool. - /// @param msg_anchor where to attach errors to - /// @param ty the type - /// @param err error message to log when check fails - void CheckNotBool(const CastableBase* msg_anchor, - const core::type::Type* ty, - const std::string& err); - - /// Validates the given instruction - /// @param inst the instruction to validate - void CheckInstruction(const Instruction* inst); - - /// Validates the given override - /// @param o the override to validate - void CheckOverride(const Override* o); - - /// Validates the given var - /// @param var the var to validate - void CheckVar(const Var* var); - - /// Validates annotations related to shader IO - /// @param msg_anchor where to attach errors to - /// @param ty type of the value under test - /// @param binding_point the binding information associated with the value - /// @param attr IO attributes associated with the values - /// @param kind the kind Shader IO being performed - void ValidateShaderIOAnnotations(const CastableBase* msg_anchor, - const core::type::Type* ty, - const std::optional& binding_point, - const IOAttributes& attr, - ShaderIOKind kind); - - /// Validates the blend_src attribute for a given type, responsible for traversal of inner types - /// and checking rules that span across a multiple attribute instances. - /// @param ctx the blend_src context. - /// @param target the object that has the struct ty. - /// @param ty the ty to validate. - /// @param attr the IO attributes for the object. - void CheckBlendSrc(BlendSrcContext& ctx, - const CastableBase* target, - const core::type::Type* ty, - const IOAttributes& attr); - - /// Validates the details of a single attribute instance. - /// @param ctx the blend_src context. - /// @param target the object that has the struct type. - /// @param ty the type to validate. - /// @param attr the IO attributes for the object. - void CheckBlendSrcImpl(BlendSrcContext& ctx, - const CastableBase* target, - const core::type::Type* ty, - const IOAttributes& attr); - - /// Validates location attributes on entry point IO. - /// @param locations the map of locations used so far for the current IO direction. - /// @param target the object that has the location attribute. - /// @param attr the IO attributes for the object. - /// @param stage the pipeline stage of the entry point. - /// @param type the type of the IO object. - /// @param dir the IO direction (input or output). - void CheckLocation(Hashmap& locations, - const CastableBase* target, - const IOAttributes& attr, - Function::PipelineStage stage, - const core::type::Type* type, - IODirection dir); - - /// Validates interpolation attributes on entry point IO. - /// @param anchor where to attach error messages to. - /// @param ty the type of the IO object - /// @param attr the IO attributes of the object. - /// @param stage the shader stage - /// @param dir the direction of the IO usage - void CheckInterpolation(const CastableBase* anchor, - const core::type::Type* ty, - const IOAttributes& attr, - Function::PipelineStage stage, - IODirection dir); - - /// Validates binding_point attributes on entry point IO. - /// @param anchor where to attach error messages to. - /// @param ty the type of the IO object - /// @param attr the IO attributes of the object - /// @param io_kind the type of shader IO object binding point is attached to - void CheckBindingPoint(const CastableBase* anchor, - const core::type::Type* ty, - const IOAttributes& attr, - const ShaderIOKind& io_kind); - - /// Validates the given let - /// @param l the let to validate - void CheckLet(const Let* l); - - /// Validates the given call - /// @param call the call to validate - void CheckCall(const Call* call); - - /// Validates the given bitcast - /// @param bitcast the bitcast to validate - void CheckBitcast(const Bitcast* bitcast); - - /// Validates that there exists the required bitcast override - /// @param bitcast the bitcast to validate types of - void CheckBitcastTypes(const Bitcast* bitcast); - - /// Validates the given builtin call - /// @param call the call to validate - void CheckBuiltinCall(const BuiltinCall* call); - - /// Validates a core builtin call - /// @param call the call to validate - /// @param overload the call intrinsic overload - void CheckCoreBuiltinCall(const CoreBuiltinCall* call, - const core::intrinsic::Overload& overload); - - /// Validates the given member builtin call - /// @param call the member call to validate - void CheckMemberBuiltinCall(const MemberBuiltinCall* call); - - /// Validates the given construct - /// @param construct the construct to validate - void CheckConstruct(const Construct* construct); - - /// Validates the given convert - /// @param convert the convert to validate - void CheckConvert(const Convert* convert); - - /// Validates the given discard - /// @note Does not validate that the discard is in a fragment shader, that - /// needs to be handled later in the validation. - /// @param discard the discard to validate - void CheckDiscard(const Discard* discard); - - /// Validates the given user call - /// @param call the call to validate - void CheckUserCall(const UserCall* call); - - /// Validates the given access - /// @param a the access to validate - void CheckAccess(const Access* a); - - /// Validates the given binary - /// @param b the binary to validate - void CheckBinary(const Binary* b); - - /// Validates the given unary - /// @param u the unary to validate - void CheckUnary(const Unary* u); - - /// Validates the given if - /// @param if_ the if to validate - void CheckIf(const If* if_); - - /// Validates the given loop - /// @param l the loop to validate - void CheckLoop(const Loop* l); - - /// Validates the loop body block - /// @param l the loop to validate - void CheckLoopBody(const Loop* l); - - /// Validates the loop continuing block - /// @param l the loop to validate - void CheckLoopContinuing(const Loop* l); - - /// Validates the given switch - /// @param s the switch to validate - void CheckSwitch(const Switch* s); - - /// Validates the given swizzle - /// @param s the swizzle to validate - void CheckSwizzle(const Swizzle* s); - - /// Validates the given terminator - /// @param b the terminator to validate - void CheckTerminator(const Terminator* b); - - /// Validates the break if instruction - /// @param b the break if to validate - void CheckBreakIf(const BreakIf* b); - - /// Validates the continue instruction - /// @param c the continue to validate - void CheckContinue(const Continue* c); - - /// Validates the given exit - /// @param e the exit to validate - void CheckExit(const Exit* e); - - /// Validates the next iteration instruction - /// @param n the next iteration to validate - void CheckNextIteration(const NextIteration* n); - - /// Validates the given exit if - /// @param e the exit if to validate - void CheckExitIf(const ExitIf* e); - - /// Validates the given return - /// @param r the return to validate - void CheckReturn(const Return* r); - - /// Validates the given unreachable - /// @param u the unreachable to validate - void CheckUnreachable(const Unreachable* u); - - /// Validates the @p exit targets a valid @p control instruction where the instruction may jump - /// over if control instructions. - /// @param exit the exit to validate - /// @param control the control instruction targeted - void CheckControlsAllowingIf(const Exit* exit, const Instruction* control); - - /// Validates the given exit switch - /// @param s the exit switch to validate - void CheckExitSwitch(const ExitSwitch* s); - - /// Validates the given exit loop - /// @param l the exit loop to validate - void CheckExitLoop(const ExitLoop* l); - - /// Validates the given load - /// @param l the load to validate - void CheckLoad(const Load* l); - - /// Validates the given store - /// @param s the store to validate - void CheckStore(const Store* s); - - /// Validates the given load vector element - /// @param l the load vector element to validate - void CheckLoadVectorElement(const LoadVectorElement* l); - - /// Validates the given store vector element - /// @param s the store vector element to validate - void CheckStoreVectorElement(const StoreVectorElement* s); - - /// Validates the given phony assignment - /// @param p the phony assignment to validate - void CheckPhony(const Phony* p); - - /// Validates that the number and types of the source instruction operands match the target's - /// values. - /// @param source_inst the source instruction - /// @param source_operand_offset the index of the first operand of the source instruction - /// @param source_operand_count the number of operands of the source instruction - /// @param target the receiver of the operand values - /// @param target_values the receiver of the operand values - void CheckOperandsMatchTarget(const Instruction* source_inst, - size_t source_operand_offset, - size_t source_operand_count, - const CastableBase* target, - VectorRef target_values); - - /// @param inst the instruction - /// @param idx the operand index - /// @returns the vector pointer type for the given instruction operand - const core::type::Type* GetVectorPtrElementType(const Instruction* inst, size_t idx); - - /// @returns true if @p ty and its elements can be loaded - bool CanLoad(const core::type::Type* ty); - - /// Executes all the pending tasks - void ProcessTasks(); - - /// Queues the block to be validated with ProcessTasks() - /// @param blk the block to validate - void QueueBlock(const Block* blk); - - /// Queues the list of instructions starting with @p inst to be validated - /// @param inst the first instruction - void QueueInstructions(const Instruction* inst); - - /// Begins validation of the block @p blk, and its instructions. - /// BeginBlock() pushes a new scope for values. - /// Must be paired with a call to EndBlock(). - void BeginBlock(const Block* blk); - - /// Ends validation of the block opened with BeginBlock() and closes the block's scope for - /// values. - void EndBlock(); - - /// Get the function that contains an instruction. - /// @param inst the instruction - /// @returns the function - const ir::Function* ContainingFunction(const ir::Instruction* inst) { - if (inst->Block() == mod_.root_block) { - return nullptr; - } - - return block_to_function_.GetOrAdd(inst->Block(), [&] { // - return ContainingFunction(inst->Block()->Parent()); - }); - } - - /// Get any endpoints that call a function. - /// @param f the function - /// @returns all end points that call the function - Hashset ContainingEndPoints(const ir::Function* f) { - if (!f) { - return {}; - } - - Hashset result{}; - Hashset visited{f}; - - auto call_sites = user_func_calls_.GetOr(f, Hashset()).Vector(); - while (!call_sites.IsEmpty()) { - auto call_site = call_sites.Pop(); - auto calling_function = ContainingFunction(call_site); - if (!calling_function) { - continue; - } - - if (visited.Contains(calling_function)) { - continue; - } - visited.Add(calling_function); - - if (calling_function->IsEntryPoint()) { - result.Add(calling_function); - } - - for (auto new_call_sites : - user_func_calls_.GetOr(f, Hashset())) { - call_sites.Push(new_call_sites); - } - } - - return result; - } - - /// ScopeStack holds a stack of values that are currently in scope - struct ScopeStack { - void Push() { stack_.Push({}); } - void Pop() { stack_.Pop(); } - void Add(const Value* value) { stack_.Back().Add(value); } - bool Contains(const Value* value) { - return stack_.Any([&](auto& v) { return v.Contains(value); }); - } - bool IsEmpty() const { return stack_.IsEmpty(); } - - private: - Vector, 4> stack_; - }; - const Module& mod_; Capabilities capabilities_; - std::optional disassembler_; // Use Disassemble() diag::List diagnostics_; - Hashset all_functions_; - Hashset visited_instructions_; - Hashmap first_continues_; - Vector control_stack_; - Vector block_stack_; - ScopeStack scope_stack_; - Vector, 16> tasks_; - SymbolTable symbols_ = SymbolTable::Wrap(mod_.symbols); - core::type::Manager type_mgr_ = core::type::Manager::Wrap(mod_.Types()); - Hashmap block_to_function_{}; - Hashmap, 4> user_func_calls_; - Hashmap stage_restricted_instructions_; - core::ir::ReferencedModuleVars referenced_module_vars_; - Hashset seen_override_ids_; - Hashset entry_point_names_; - Hashset validated_types_{}; }; -Validator::Validator(const Module& mod, Capabilities capabilities) - : mod_(mod), capabilities_(capabilities), referenced_module_vars_(mod) {} - -Validator::~Validator() = default; - -Disassembler& Validator::Disassemble() { - if (!disassembler_) { - disassembler_.emplace(ir::Disassembler(mod_)); - } - return *disassembler_; -} - -Result Validator::Run() { - RunStructuralSoundnessChecks(); - - CheckForRecursion(); - CheckForOrphanedInstructions(); - CheckStageRestrictedInstructions(); - - if (diagnostics_.ContainsErrors()) { - diagnostics_.AddNote(Source{}) << "# Disassembly\n" << Disassemble().Text(); - return Failure{diagnostics_.Str()}; - } - return Success; -} - -void Validator::CheckForRecursion() { - if (diagnostics_.ContainsErrors()) { - return; - } - - ReferencedFunctions referenced_functions(mod_); - for (auto& func : mod_.functions) { - auto& refs = referenced_functions.TransitiveReferences(func); - if (refs.Contains(func)) { - // TODO(434684891): Consider improving this error with more information. - AddError(func) << "recursive function calls are not allowed"; - return; - } - } -} - -void Validator::CheckForOrphanedInstructions() { - if (diagnostics_.ContainsErrors()) { - return; - } - - // Check for orphaned instructions. - for (auto* inst : mod_.Instructions()) { - if (!visited_instructions_.Contains(inst)) { - AddError(inst) << "orphaned instruction: " << inst->FriendlyName(); - } - } -} - -void Validator::CheckStageRestrictedInstructions() { - if (diagnostics_.ContainsErrors()) { - return; - } - - // Check for instructions being used in stages that do not support them. - for (const auto& i : stage_restricted_instructions_) { - const auto& inst = i.key; - const auto& stages = i.value; - const auto* f = ContainingFunction(inst); - if (f == nullptr) { - continue; - } - - if (f->IsEntryPoint() && !stages.Contains(f->Stage())) { - AddError(inst) << "cannot be used in a " << f->Stage() << " shader"; - } else { - for (const Function* ep : ContainingEndPoints(f)) { - if (!stages.Contains(ep->Stage())) { - AddError(inst) << "cannot be used in a " << ep->Stage() << " shader"; - } - } - } - } -} - -void Validator::RunStructuralSoundnessChecks() { - scope_stack_.Push(); - TINT_DEFER({ - scope_stack_.Pop(); - TINT_ASSERT(scope_stack_.IsEmpty()); - TINT_ASSERT(tasks_.IsEmpty()); - TINT_ASSERT(control_stack_.IsEmpty()); - TINT_ASSERT(block_stack_.IsEmpty()); - }); - CheckRootBlock(mod_.root_block); - - for (auto& func : mod_.functions) { - if (!all_functions_.Add(func)) { - AddError(func) << "function " << NameOf(func) << " added to module multiple times"; - } - scope_stack_.Add(func); - } - - for (auto& func : mod_.functions) { - block_to_function_.Add(func->Block(), func); - CheckFunction(func); - } -} - -diag::Diagnostic& Validator::AddError(const Instruction* inst) { - auto src = Disassemble().InstructionSource(inst); - auto& diag = AddError(src) << inst->FriendlyName() << ": "; - - if (!block_stack_.IsEmpty()) { - AddNote(block_stack_.Back()) << "in block"; - - // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we - // need to get a new reference to the error diagnostic here. - return *(diagnostics_.end() - 2); - } - return diag; -} - -diag::Diagnostic& Validator::AddError(const Instruction* inst, size_t idx) { - auto src = - Disassemble().OperandSource(Disassembler::IndexedValue{inst, static_cast(idx)}); - auto& diag = AddError(src) << inst->FriendlyName() << ": "; - - if (!block_stack_.IsEmpty()) { - AddNote(block_stack_.Back()) << "in block"; - - // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we - // need to get a new reference to the error diagnostic here. - return *(diagnostics_.end() - 2); - } - return diag; -} - -diag::Diagnostic& Validator::AddResultError(const Instruction* inst, size_t idx) { - auto src = - Disassemble().ResultSource(Disassembler::IndexedValue{inst, static_cast(idx)}); - auto& diag = AddError(src) << inst->FriendlyName() << ": "; - - if (!block_stack_.IsEmpty()) { - AddNote(block_stack_.Back()) << "in block"; - - // Adding the note may trigger a resize and invalidate the error diagnostic reference, so we - // need to get a new reference to the error diagnostic here. - return *(diagnostics_.end() - 2); - } - return diag; -} - -diag::Diagnostic& Validator::AddError(const Block* blk) { - auto src = Disassemble().BlockSource(blk); - return AddError(src); -} - -diag::Diagnostic& Validator::AddError(const BlockParam* param) { - auto src = Disassemble().BlockParamSource(param); - return AddError(src); -} - -diag::Diagnostic& Validator::AddError(const Function* func) { - auto src = Disassemble().FunctionSource(func); - return AddError(src); -} - -diag::Diagnostic& Validator::AddError(const FunctionParam* param) { - auto src = Disassemble().FunctionParamSource(param); - return AddError(src); -} - -diag::Diagnostic& Validator::AddError(const CastableBase* base) { - diag::Diagnostic* diag = nullptr; - tint::Switch( - base, // - [&](const Block* block) { diag = &AddError(block); }, - [&](const BlockParam* param) { diag = &AddError(param); }, - [&](const Function* fn) { diag = &AddError(fn); }, - [&](const FunctionParam* param) { diag = &AddError(param); }, - [&](const Instruction* inst) { diag = &AddError(inst); }, - [&](const InstructionResult* res) { diag = &AddError(res); }); - TINT_ASSERT(diag); - return *diag; -} - -diag::Diagnostic& Validator::AddNote(const Instruction* inst) { - auto src = Disassemble().InstructionSource(inst); - return AddNote(src); -} - -diag::Diagnostic& Validator::AddNote(const Function* func) { - auto src = Disassemble().FunctionSource(func); - return AddNote(src); -} - -diag::Diagnostic& Validator::AddOperandNote(const Instruction* inst, size_t idx) { - auto src = - Disassemble().OperandSource(Disassembler::IndexedValue{inst, static_cast(idx)}); - return AddNote(src); -} - -diag::Diagnostic& Validator::AddResultNote(const Instruction* inst, size_t idx) { - auto src = - Disassemble().ResultSource(Disassembler::IndexedValue{inst, static_cast(idx)}); - return AddNote(src); -} - -diag::Diagnostic& Validator::AddNote(const Block* blk) { - auto src = Disassemble().BlockSource(blk); - return AddNote(src); -} - -diag::Diagnostic& Validator::AddError(Source src) { - auto& diag = diagnostics_.AddError(src); - diag.owned_file = Disassemble().File(); - return diag; -} - -diag::Diagnostic& Validator::AddNote(Source src) { - auto& diag = diagnostics_.AddNote(src); - diag.owned_file = Disassemble().File(); - return diag; -} - -void Validator::AddDeclarationNote(const CastableBase* decl) { - tint::Switch( - decl, // - [&](const Block* block) { AddDeclarationNote(block); }, - [&](const BlockParam* param) { AddDeclarationNote(param); }, - [&](const Function* fn) { AddDeclarationNote(fn); }, - [&](const FunctionParam* param) { AddDeclarationNote(param); }, - [&](const Instruction* inst) { AddDeclarationNote(inst); }, - [&](const InstructionResult* res) { AddDeclarationNote(res); }); -} - -void Validator::AddDeclarationNote(const Block* block) { - auto src = Disassemble().BlockSource(block); - if (src.file) { - AddNote(src) << NameOf(block) << " declared here"; - } -} - -void Validator::AddDeclarationNote(const BlockParam* param) { - auto src = Disassemble().BlockParamSource(param); - if (src.file) { - AddNote(src) << NameOf(param) << " declared here"; - } -} - -void Validator::AddDeclarationNote(const Function* fn) { - AddNote(fn) << NameOf(fn) << " declared here"; -} - -void Validator::AddDeclarationNote(const FunctionParam* param) { - auto src = Disassemble().FunctionParamSource(param); - if (src.file) { - AddNote(src) << NameOf(param) << " declared here"; - } -} - -void Validator::AddDeclarationNote(const Instruction* inst) { - auto src = Disassemble().InstructionSource(inst); - if (src.file) { - AddNote(src) << NameOf(inst) << " declared here"; - } -} - -void Validator::AddDeclarationNote(const InstructionResult* res) { - if (auto* inst = res->Instruction()) { - auto results = inst->Results(); - for (size_t i = 0; i < results.Length(); i++) { - if (results[i] == res) { - AddResultNote(res->Instruction(), i) << NameOf(res) << " declared here"; - return; - } - } - } -} - -StyledText Validator::NameOf(const CastableBase* decl) { - return tint::Switch( - decl, // - [&](const core::type::Type* ty) { return NameOf(ty); }, - [&](const Value* value) { return NameOf(value); }, - [&](const Instruction* inst) { return NameOf(inst); }, - [&](const Block* block) { return NameOf(block); }, // - TINT_ICE_ON_NO_MATCH); -} - -StyledText Validator::NameOf(const core::type::Type* ty) { - auto name = ty ? ty->FriendlyName() : "undef"; - return StyledText{} << style::Type(name); -} - -StyledText Validator::NameOf(const Value* value) { - return Disassemble().NameOf(value); -} - -StyledText Validator::NameOf(const Instruction* inst) { - auto name = inst ? inst->FriendlyName() : "undef"; - return StyledText{} << style::Instruction(name); -} - -StyledText Validator::NameOf(const Block* block) { - auto parent_name = block->Parent() ? block->Parent()->FriendlyName() : "undef"; - return StyledText{} << style::Instruction(parent_name) << " block " - << Disassemble().NameOf(block); -} - -bool Validator::CheckResult(const Instruction* inst, size_t idx) { - auto* result = inst->Result(idx); - if (DAWN_UNLIKELY(result == nullptr)) { - AddResultError(inst, idx) << "result is undefined"; - return false; - } - - if (DAWN_UNLIKELY(result->Type() == nullptr)) { - AddResultError(inst, idx) << "result type is undefined"; - return false; - } - - if (DAWN_UNLIKELY(result->Instruction() == nullptr)) { - AddResultError(inst, idx) << "result instruction is undefined"; - return false; - } - - if (DAWN_UNLIKELY(result->Instruction() != inst)) { - AddResultError(inst, idx) - << "result instruction does not match instruction (possible double usage)"; - return false; - } - - if (!inst->Is() && result->Type()->Is()) { - AddResultError(inst, idx) << "result type cannot be void"; - return false; - } - - if (inst->Is()) { - if (result->Type()->Is()) { - AddResultError(inst, idx) << "result type cannot be a pointer"; - return false; - } - if (!result->Type()->IsConstructible()) { - AddResultError(inst, idx) << "result type must be constructable"; - return false; - } - } - - if (result->Type()->Is() && mod_.NameOf(result)) { - AddResultError(inst, idx) << "void results must not have names"; - return false; - } - - return true; -} - -bool Validator::CheckResults(const ir::Instruction* inst, std::optional count = {}) { - if (count.has_value()) { - if (DAWN_UNLIKELY(inst->Results().Length() != count.value())) { - AddError(inst) << "expected exactly " << count.value() << " results, got " - << inst->Results().Length(); - return false; - } - } - - bool passed = true; - Hashset seen_instruction_results; - for (size_t i = 0; i < inst->Results().Length(); i++) { - if (DAWN_UNLIKELY(!CheckResult(inst, i))) { - passed = false; - } - - if (!seen_instruction_results.Add(inst->Result(i))) { - AddResultError(inst, i) << "result was seen previously as a result"; - passed = false; - } - } - return passed; -} - -bool Validator::CheckOperand(const Instruction* inst, size_t idx) { - auto* operand = inst->Operand(idx); - - if (DAWN_UNLIKELY(operand == nullptr)) { - // var instructions are allowed to have a nullptr initializers. - // terminator instructions use nullptr operands to signal 'undef'. - if (inst->IsAnyOf()) { - return true; - } - - AddError(inst, idx) << "operand is undefined"; - return false; - } - - // ir::Unused is a internal value used by some transforms to track unused entries, and is - // removed as part of generating an output shader. - if (DAWN_UNLIKELY(operand->Is())) { - return true; - } - - if (DAWN_UNLIKELY(operand->Type() == nullptr)) { - AddError(inst, idx) << "operand type is undefined"; - return false; - } - - if (DAWN_UNLIKELY(!operand->Alive())) { - AddError(inst, idx) << "operand is not alive"; - return false; - } - - if (DAWN_UNLIKELY(!operand->HasUsage(inst, idx))) { - AddError(inst, idx) << "operand missing usage"; - return false; - } - - if (auto fn = operand->As(); fn && !all_functions_.Contains(fn)) { - AddError(inst, idx) << NameOf(operand) << " is not part of the module"; - return false; - } - - if (DAWN_UNLIKELY(!operand->Is() && !operand->Is() && - !scope_stack_.Contains(operand))) { - AddError(inst, idx) << NameOf(operand) << " is not in scope"; - AddDeclarationNote(operand); - return false; - } - - return true; -} - -bool Validator::CheckOperands(const ir::Instruction* inst, - size_t min_count, - std::optional max_count) { - if (DAWN_UNLIKELY(inst->Operands().Length() < min_count)) { - if (max_count.has_value()) { - AddError(inst) << "expected between " << min_count << " and " << max_count.value() - << " operands, got " << inst->Operands().Length(); - } else { - AddError(inst) << "expected at least " << min_count << " operands, got " - << inst->Operands().Length(); - } - return false; - } - - if (DAWN_UNLIKELY(max_count.has_value() && inst->Operands().Length() > max_count.value())) { - AddError(inst) << "expected between " << min_count << " and " << max_count.value() - << " operands, got " << inst->Operands().Length(); - return false; - } - - bool passed = true; - for (size_t i = 0; i < inst->Operands().Length(); i++) { - if (DAWN_UNLIKELY(!CheckOperand(inst, i))) { - passed = false; - } - } - return passed; -} - -bool Validator::CheckOperands(const ir::Instruction* inst, std::optional count = {}) { - if (count.has_value()) { - if (DAWN_UNLIKELY(inst->Operands().Length() != count.value())) { - AddError(inst) << "expected exactly " << count.value() << " operands, got " - << inst->Operands().Length(); - return false; - } - } - - bool passed = true; - for (size_t i = 0; i < inst->Operands().Length(); i++) { - if (DAWN_UNLIKELY(!CheckOperand(inst, i))) { - passed = false; - } - } - return passed; -} - -bool Validator::CheckResultsAndOperandRange(const ir::Instruction* inst, - size_t num_results, - size_t min_operands, - std::optional max_operands = {}) { - // Intentionally avoiding short-circuiting here - bool results_passed = CheckResults(inst, num_results); - bool operands_passed = CheckOperands(inst, min_operands, max_operands); - return results_passed && operands_passed; -} - -bool Validator::CheckResultsAndOperands(const ir::Instruction* inst, - size_t num_results, - size_t num_operands) { - // Intentionally avoiding short-circuiting here - bool results_passed = CheckResults(inst, num_results); - bool operands_passed = CheckOperands(inst, num_operands); - return results_passed && operands_passed; -} - -void Validator::CheckType(const core::type::Type* root, - std::function diag, - Capabilities ignore_caps, - Capabilities allow_caps) { - if (root == nullptr) { - return; - } - - if (!capabilities_.Contains(Capability::kAllowNonCoreTypes)) { - // Check for core types, which are the only types declared in the `tint::core` namespace. - if (!std::string_view(root->TypeInfo().name).starts_with("tint::core")) { - diag() << "non-core types not allowed in core IR"; - return; - } - } - - if (!validated_types_.Add(ValidatedType{root, ignore_caps})) { - return; - } - - AddressSpace addrspace = AddressSpace::kUndefined; - if (auto* mv = root->As()) { - addrspace = mv->AddressSpace(); - } - - auto visit = [&](const core::type::Type* type) { - if (type->IsAbstract()) { - diag() << "abstracts are not permitted"; - return false; - } - - return tint::Switch( - type, - [&](const core::type::Struct* str) { - uint32_t cur_offset = 0; - for (auto* member : str->Members()) { - if (member->Type()->Is()) { - diag() << "struct member " << member->Index() << " cannot have void type"; - return false; - } - - if (!capabilities_.Contains(Capability::kMslAllowEntryPointInterface)) { - if (member->Type()->Is()) { - diag() << "struct member " << member->Index() - << " cannot be a pointer type"; - return false; - } - - if (member->Type()->Is()) { - diag() << "struct member " << member->Index() - << " cannot be a texture type"; - return false; - } - - if (member->Type()->Is()) { - diag() << "struct member " << member->Index() - << " cannot be a sampler type"; - return false; - } - } - - if (auto* arr = member->Type()->As(); - arr && arr->Count()->Is()) { - if (member != str->Members().Back()) { - diag() << "runtime-sized arrays can only be the last member of a " - "struct"; - return false; - } - } - - if (member->Align() == 0) { - diag() << "struct member must not have an alignment of 0"; - return false; - } - if (member->Type()->Align() == 0) { - diag() << "struct member type must not have an alignment of 0"; - return false; - } - - if (!capabilities_.Contains(Capability::kAllowStructMatrixDecorations)) { - if (member->RowMajor()) { - diag() << "Row major annotation not allowed on structures"; - return false; - } - if (member->HasMatrixStride()) { - diag() << "Matrix stride annotation not allowed on structures"; - return false; - } - } - - // TODO(448608979): Remove guard once updated to handle RowMajor correctly - if (!member->RowMajor()) { - if (member->Size() < member->Type()->Size()) { - diag() << "struct member " << member->Index() - << " with size=" << member->Size() - << " must be at least as large as the type with size " - << member->Type()->Size(); - return false; - } - - if (member->Align() % member->Type()->Align() != 0) { - diag() << "struct member alignment (" << member->Align() - << ") must be divisible by type alignment (" - << member->Type()->Align() << ")"; - return false; - } - } - - auto padding = member->Offset() - cur_offset; - if (padding >= internal_limits::kMaxStructMemberPadding) { - diag() << "struct member padding (" << padding - << ") is larger then the max (" - << internal_limits::kMaxStructMemberPadding << ")"; - return false; - } - cur_offset += padding + member->MinimumRequiredSize(); - } - if (str->Size() < cur_offset) { - diag() << "struct size (" << str->Size() - << ") is smaller than the end of the last member (" << cur_offset << ")"; - return false; - } - - auto padding = str->Size() - cur_offset; - if (padding >= internal_limits::kMaxStructMemberPadding) { - diag() << "struct padding (" << padding << ") is larger then the max (" - << internal_limits::kMaxStructMemberPadding << ")"; - return false; - } - - return true; - }, - [&](const core::type::Reference* ref) { - if (ref->StoreType()->Is()) { - diag() << "references to void are not permitted"; - return false; - } - - // Reference types are guarded by the AllowRefTypes capability. - if (!capabilities_.Contains(Capability::kAllowRefTypes) || - ignore_caps.Contains(Capability::kAllowRefTypes)) { - diag() << "reference types are not permitted here"; - return false; - } else if (type != root) { - // If they are allowed, reference types still cannot be nested. - diag() << "nested reference types are not permitted"; - return false; - } - return true; - }, - [&](const core::type::Pointer* ptr) { - if (ptr->StoreType()->Is()) { - diag() << "pointers to void are not permitted"; - return false; - } - - if (ptr->AddressSpace() == AddressSpace::kUniform || - ptr->AddressSpace() == AddressSpace::kHandle) { - if (ptr->Access() != core::Access::kRead) { - diag() << "uniform and handle pointers must be read access"; - return false; - } - } - - if (ptr->AddressSpace() == AddressSpace::kWorkgroup) { - if (ptr->Access() != core::Access::kReadWrite) { - diag() << "workgroup pointers must be read_write access"; - return false; - } - } - - if (ptr->AddressSpace() == AddressSpace::kHandle) { - if (!ptr->StoreType()->IsHandle()) { - diag() << "the 'handle' address space can only be used for handle types"; - return false; - } - } else { - if (ptr->StoreType()->IsHandle()) { - diag() << "handle types can only be declared in the 'handle' address space"; - return false; - } - } - - if (ptr->AddressSpace() == core::AddressSpace::kImmediate) { - if (ptr->Access() != core::Access::kRead) { - diag() << "immediate pointers must be read access"; - return false; - } - } - - if (ptr->StoreType()->Is()) { - diag() << "pointers to pointers are not allowed"; - return false; - } - return true; - }, - [&](const core::type::U64*) { - // u64 types are guarded by the Allow64BitIntegers capability. - if (!capabilities_.Contains(Capability::kAllow64BitIntegers) && - !allow_caps.Contains(Capability::kAllow64BitIntegers)) { - diag() << "64-bit integer types are not permitted"; - return false; - } - return true; - }, - [&](const core::type::I8*) { - // i8 types are guarded by the Allow8BitIntegers capability. - if (!capabilities_.Contains(Capability::kAllow8BitIntegers)) { - diag() << "8-bit integer types are not permitted"; - return false; - } - return true; - }, - [&](const core::type::U8*) { - // u8 types are guarded by the Allow8BitIntegers capability. - if (!capabilities_.Contains(Capability::kAllow8BitIntegers)) { - diag() << "8-bit integer types are not permitted"; - return false; - } - return true; - }, - [&](const core::type::U16*) { - // u16 types are guarded by the Allow16BitIntegers capability. - if (!capabilities_.Contains(Capability::kAllow16BitIntegers)) { - diag() << "16-bit integer types are not permitted"; - return false; - } - return true; - }, - [&](const core::type::Array* arr) { - if (!arr->ElemType()->HasCreationFixedFootprint()) { - diag() << "array elements, " << NameOf(type) - << ", must have creation-fixed footprint"; - return false; - } - if (arr->Count()->Is()) { - if (addrspace != AddressSpace::kStorage) { - diag() << "runtime arrays must be in the 'storage' address space"; - return false; - } - } else if (auto* count = arr->Count()->As()) { - if (count->value == 0) { - diag() << "array requires a constant array size > 0"; - return false; - } - } - return true; - }, - [&](const core::type::Vector* v) { - if (!v->Type()->IsScalar()) { - diag() << "vector elements, " << NameOf(type) << ", must be scalars"; - return false; - } - return true; - }, - [&](const core::type::Matrix* m) { - if (!m->Type()->IsFloatScalar()) { - diag() << "matrix elements, " << NameOf(type) << ", must be float scalars"; - return false; - } - return true; - }, - [&](const core::type::Atomic* a) { - // Prior to lowering we allow for atomic operations on vec2u to support the - // AtomicVec2UMinMax feature. - if (auto* vec = a->Type()->As()) { - if (vec->Width() == 2 && vec->Type()->Is()) { - return true; - } - } - - if (!a->Type()->IsAnyOf()) { - diag() << "atomic subtype must be i32, u32 or u64 type is " - << NameOf(a->Type()); - return false; - } - return true; - }, - [&](const core::type::SampledTexture* s) { - if (!s->Type()->IsAnyOf()) { - diag() << "invalid sampled texture sample type: " << NameOf(s->Type()); - return false; - } - return true; - }, - [&](const core::type::MultisampledTexture* ms) { - if (!ms->Type()->IsAnyOf()) { - diag() << "invalid multisampled texture sample type: " << NameOf(ms->Type()); - return false; - } - - switch (ms->Dim()) { - case core::type::TextureDimension::k2d: - break; - default: - diag() << "invalid multisampled texture dimension: " - << style::Literal(ToString(ms->Dim())); - return false; - } - return true; - }, - [&](const core::type::StorageTexture* s) { - switch (s->Dim()) { - case core::type::TextureDimension::kCube: - case core::type::TextureDimension::kCubeArray: - diag() << "dimension " << style::Literal(ToString(s->Dim())) - << " for storage textures does not in WGSL yet"; - return false; - case core::type::TextureDimension::kNone: - diag() << "invalid texture dimension " - << style::Literal(ToString(s->Dim())); - return false; - default: - return true; - } - }, - [&](const core::type::InputAttachment* i) { - if (!i->Type()->IsAnyOf()) { - diag() << "invalid input attachment component type: " << NameOf(i->Type()); - return false; - } - return true; - }, - [&](const core::type::SubgroupMatrix* m) { - if (!m->Type() - ->IsAnyOf()) { - diag() << "invalid subgroup matrix component type: " << NameOf(m->Type()); - return false; - } - if (!(addrspace == AddressSpace::kUndefined || - addrspace == AddressSpace::kFunction)) { - diag() << "invalid address space for subgroup matrix : " << addrspace; - return false; - } - return true; - }, - [&](const core::type::BindingArray* t) { - if (!t->Count()->Is()) { - diag() << "binding_array count must be a constant expression"; - return false; - } - - auto count = t->Count()->As()->value; - if (count == 0) { - diag() << "binding array requires a constant array size > 0"; - return false; - } - - if (!(addrspace == AddressSpace::kUndefined || - addrspace == AddressSpace::kHandle) && - !capabilities_.Contains(Capability::kMslAllowEntryPointInterface)) { - diag() << "invalid address space for binding_array : " << addrspace; - return false; - } - - if (!capabilities_.Contains(Capability::kAllowNonCoreTypes)) { - if (!t->ElemType()->Is()) { - diag() << "binding_array element type must be a sampled texture type"; - return false; - } - } - return true; - }, - [](Default) { return true; }); - }; - - Vector stack{root}; - Hashset seen{}; - while (!stack.IsEmpty()) { - auto* ty = stack.Pop(); - if (!ty) { - continue; - } - if (!visit(ty)) { - return; - } - - if (auto* view = ty->As(); view && seen.Add(view)) { - stack.Push(view->StoreType()); - continue; - } - - // Visit the elements of a composite type. - auto type_count = ty->Elements(); - if (type_count.type) { - // Every element has the same type (e.g. array, vector, matrix, ...), so validate that - // type once if it has not been seen before. - if (seen.Add(type_count.type)) { - stack.Push(type_count.type); - } - } else { - // Different elements have different types (e.g. a struct), so we need to validate each - // of them if they have not been seen before. - for (uint32_t i = 0; i < type_count.count; i++) { - if (auto* subtype = ty->Element(i); subtype && seen.Add(subtype)) { - stack.Push(subtype); - } - } - } - } -} - -void Validator::CheckRootBlock(const Block* blk) { - block_stack_.Push(blk); - TINT_DEFER(block_stack_.Pop()); - - Hashset pipeline_evaluatable{}; - - auto add_evaluatable = [&](const Instruction* inst, const bool is_creatable) { - if (auto* res = inst->Result(0); res != nullptr && is_creatable) { - pipeline_evaluatable.Add(res); - } - }; - - for (auto* inst : *blk) { - if (inst->Block() != blk) { - AddError(inst) << "instruction in root block does not have root block as parent"; - continue; - } - - auto is_pipeline_creatable = true; - for (auto* op : inst->Operands()) { - if (!op) { - continue; - } - if (op->Is()) { - continue; - } - if (pipeline_evaluatable.Contains(op)) { - continue; - } - is_pipeline_creatable = false; - break; - } - - if (!is_pipeline_creatable) { - AddError(inst) << "instruction is not evaluatable at pipeline creation time"; - } - - tint::Switch( - inst, // - [&](const core::ir::Override* o) { - if (capabilities_.Contains(Capability::kAllowOverrides)) { - CheckInstruction(o); - add_evaluatable(o, is_pipeline_creatable); - } else { - AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; - } - }, - [&](const core::ir::Var* var) { CheckInstruction(var); }, - [&](const core::ir::Let* let) { - if (capabilities_.Contains(Capability::kAllowModuleScopeLets)) { - CheckInstruction(let); - add_evaluatable(let, is_pipeline_creatable); - } else { - AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; - } - }, - [&](const core::ir::Construct* c) { - if (capabilities_.Contains(Capability::kAllowModuleScopeLets) || - capabilities_.Contains(Capability::kAllowOverrides)) { - CheckInstruction(c); - CheckOnlyUsedInRootBlock(inst); - add_evaluatable(c, is_pipeline_creatable); - } else { - AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; - } - }, - [&](Default) { - // Note, this validation around kAllowOverrides is looser than it could be. There - // are only certain expressions and builtins which can be used in an override, which - // currently isn't checked. - if (capabilities_.Contains(Capability::kAllowOverrides) && - inst->IsAnyOf()) { - CheckInstruction(inst); - // If overrides are allowed we can have certain regular instructions in the root - // block, with the caveat that those instructions can _only_ be used in the root - // block. - CheckOnlyUsedInRootBlock(inst); - add_evaluatable(inst, is_pipeline_creatable); - } else { - AddError(inst) << "root block: invalid instruction: " << inst->TypeInfo().name; - } - }); - } - // Our ConstExprIfs in the root require us to process tasks here. - ProcessTasks(); -} - -void Validator::CheckOnlyUsedInRootBlock(const Instruction* inst) { - if (inst->Result(0)) { - for (auto& usage : inst->Result(0)->UsagesSorted()) { - if (usage.instruction->Block() != mod_.root_block) { - AddError(inst) << "root block: instruction used outside of root block " - << inst->TypeInfo().name; - } - } - } - - CheckInstruction(inst); -} - -void Validator::CheckFunction(const Function* func) { - // Scope holds the parameters and block - scope_stack_.Push(); - TINT_DEFER(scope_stack_.Pop()); - - if (func->IsEntryPoint()) { - // Check that there is at most one entry point unless we allow multiple entry points. - if (!capabilities_.Contains(Capability::kAllowMultipleEntryPoints)) { - if (!entry_point_names_.IsEmpty()) { - AddError(func) << "a module with multiple entry points requires the " - "AllowMultipleEntryPoints capability"; - return; - } - } - - // Checking the name early, so its usage can be recorded, even if the function is malformed. - const auto name = mod_.NameOf(func).Name(); - if (!entry_point_names_.Add(name)) { - AddError(func) << "entry point name " << style::Function(name) << " is not unique"; - } - } - - if (!func->Type() || !func->Type()->Is()) { - AddError(func) << "functions must have type ''"; - return; - } - - if (!func->Block()) { - AddError(func) << "root block for function is undefined"; - return; - } - - if (func->Block()->Is()) { - AddError(func) << "root block for function cannot be a multi-in block"; - return; - } - - Hashset param_set{}; - for (auto* param : func->Params()) { - if (!param->Alive()) { - AddError(param) << "destroyed parameter found in function parameter list"; - return; - } - if (!param->Function()) { - AddError(param) << "function parameter has nullptr parent function"; - return; - } else if (param->Function() != func) { - AddError(param) << "function parameter has incorrect parent function"; - AddNote(param->Function()) << "parent function declared here"; - return; - } - - if (!param->Type()) { - AddError(param) << "function parameter has nullptr type"; - return; - } - - if (!param_set.Add(param)) { - AddError(param) << "function parameter is not unique"; - continue; - } - - // References not allowed on function signatures even with Capability::kAllowRefTypes. - CheckType( - param->Type(), [&]() -> diag::Diagnostic& { return AddError(param); }, - Capabilities{Capability::kAllowRefTypes}); - - if (!IsValidFunctionParamType(param->Type())) { - auto ptr_ty = param->Type()->As(); - bool allowed_ptr_to_handle = - capabilities_.Contains(Capability::kAllowPointerToHandle) && ptr_ty != nullptr && - ptr_ty->StoreType()->IsHandle(); - - auto struct_ty = param->Type()->As(); - if (!allowed_ptr_to_handle && - (!capabilities_.Contains(Capability::kMslAllowEntryPointInterface) || - (struct_ty == nullptr) || - struct_ty->Members().Any([](const core::type::StructMember* m) { - return !IsValidFunctionParamType(m->Type()); - }))) { - AddError(param) << "function parameter type, " << NameOf(param->Type()) - << ", must be constructible, a pointer, or a handle"; - } - } - if (func->IsEntryPoint() && - !capabilities_.Contains(Capability::kMslAllowEntryPointInterface)) { - if (param->Type()->Is()) { - AddError(param) << "entry point parameters cannot be pointers"; - } - } - - if (func->IsFragment()) { - WalkTypeAndMembers(param, param->Type(), param->Attributes(), - [this](const auto* p, const auto* t, const auto& a) { - CheckFrontFacingIfBool( - p, a, t, - "fragment entry point params can only be a bool if " - "decorated with @builtin(front_facing)"); - }); - } else if (func->IsEntryPoint()) { - WalkTypeAndMembers( - param, param->Type(), param->Attributes(), - [this](const auto* p, const auto* t, const auto&) { - CheckNotBool(p, t, - "entry point params can only be a bool for fragment shaders"); - }); - } - - AddressSpace address_space = AddressSpace::kUndefined; - auto* mv = param->Type()->As(); - if (mv) { - address_space = mv->AddressSpace(); - } else { - // ModuleScopeVars transform in MSL backends unwraps pointers to handles - if (param->Type()->IsHandle()) { - address_space = AddressSpace::kHandle; - } - } - - if (address_space == AddressSpace::kPixelLocal) { - if (!mv->StoreType()->Is()) { - AddError(param) << "pixel_local param must be of type struct"; - } - } - - if (func->IsEntryPoint()) { - ValidateShaderIOAnnotations(param, param->Type(), param->BindingPoint(), - param->Attributes(), ShaderIOKind::kInputParam); - } else { - if (param->BindingPoint().has_value()) { - AddError(param) - << "input param to non-entry point function has a binding point set"; - } - - if (param->Builtin().has_value()) { - AddError(param) << "builtins can only be decorated on entry point params"; - } - } - - if (!capabilities_.Contains(Capability::kMslAllowEntryPointInterface) && - func->IsEntryPoint()) { - if (mv && mv->Is() && address_space == AddressSpace::kWorkgroup) { - AddError(param) << "input param to entry point cannot be a ptr in the 'workgroup' " - "address space"; - } - } - - scope_stack_.Add(param); - } - - // References not allowed on function signatures even with Capability::kAllowRefTypes. - CheckType( - func->ReturnType(), [&]() -> diag::Diagnostic& { return AddError(func); }, - Capabilities{Capability::kAllowRefTypes}); - - // void needs to be filtered out, since it isn't constructible, but used in the IR when no - // return is specified. - if (DAWN_UNLIKELY(!func->ReturnType()->Is() && - !func->ReturnType()->IsConstructible())) { - AddError(func) << "function return type must be constructible"; - } - - ValidateIOAttributes(func); - - if (func->IsEntryPoint()) { - if (DAWN_UNLIKELY(mod_.NameOf(func).Name().empty())) { - AddError(func) << "entry points must have names"; - } - } - - CheckWorkgroupSize(func); - - CheckSubgroupSize(func); - - if (func->Stage() == Function::PipelineStage::kCompute) { - if (DAWN_UNLIKELY(func->ReturnType() && !func->ReturnType()->Is())) { - AddError(func) << "compute entry point must not have a return type, found " - << NameOf(func->ReturnType()); - } - } - - if (func->IsEntryPoint()) { - ValidateShaderIOAnnotations(func, func->ReturnType(), std::nullopt, - func->ReturnAttributes(), ShaderIOKind::kResultValue); - - WalkTypeAndMembers( - func, func->ReturnType(), func->ReturnAttributes(), - [this](const Function* f, const core::type::Type* t, const IOAttributes&) { - CheckNotBool(f, t, "entry point returns can not be 'bool'"); - }); - - Hashset binding_points{}; - const Var* user_declared_immediate = nullptr; - - for (auto var : referenced_module_vars_.TransitiveReferences(func)) { - if (!capabilities_.Contains(Capability::kAllowDuplicateBindings) && - var->BindingPoint().has_value()) { - auto bp = var->BindingPoint().value(); - if (!binding_points.Add(bp)) { - AddError(var) << "found non-unique binding point, " << bp - << ", being referenced in entry point, " << NameOf(func); - } - } - - const auto* mv = var->Result()->Type()->As(); - const auto* ty = var->Result()->Type()->UnwrapPtrOrRef(); - const auto attr = var->Attributes(); - if (!mv || !ty) { - continue; - } - - if (mv->AddressSpace() == AddressSpace::kImmediate) { - if (user_declared_immediate) { - AddError(var) << "multiple user-declared immediate data variables referenced " - "by entry point " - << NameOf(func); - return; - } - user_declared_immediate = var; - } - - if (mv->AddressSpace() != AddressSpace::kIn && - mv->AddressSpace() != AddressSpace::kOut) { - continue; - } - - if (func->IsFragment() && mv->AddressSpace() == AddressSpace::kIn) { - WalkTypeAndMembers( - var, ty, attr, [this](const auto* v, const auto* t, const auto& a) { - CheckFrontFacingIfBool( - v, a, t, - "input address space values referenced by fragment shaders " - "can only be 'bool' if decorated with " - "@builtin(front_facing)"); - }); - } else { - WalkTypeAndMembers( - var, ty, attr, [this](const auto* v, const auto* t, const auto&) { - CheckNotBool( - v, t, - "IO address space values referenced by shader entry points can " - "only be 'bool' if in the input space, used only by fragment " - "shaders and decorated with @builtin(front_facing)"); - }); - } - } - } - - if (func->IsVertex()) { - CheckPositionPresentForVertexOutput(func); - } - - QueueBlock(func->Block()); - ProcessTasks(); -} - -void Validator::ValidateIOAttributes(const Function* func) { - const auto stage = func->Stage(); - struct Task { - const CastableBase* anchor; - const core::type::Type* type; - const IOAttributes& attr; - IODirection dir; - ShaderIOKind io_kind; - }; - Vector tasks; - - // Gather parameters. - for (auto* param : func->Params()) { - tasks.Push({param, param->Type(), param->Attributes(), IODirection::kInput, - ShaderIOKind::kInputParam}); - } - - // Gather return value. - tasks.Push({func, func->ReturnType(), func->ReturnAttributes(), IODirection::kOutput, - ShaderIOKind::kResultValue}); - - // Gather referenced module variables. - for (auto* var : referenced_module_vars_.TransitiveReferences(func)) { - auto* mv = var->Result()->Type()->As(); - if (mv == nullptr) { - continue; - } - if (mv->AddressSpace() == AddressSpace::kIn || mv->AddressSpace() == AddressSpace::kOut || - mv->AddressSpace() == AddressSpace::kHandle) { - tasks.Push({var, mv->StoreType(), var->Attributes(), IODirectionFor(mv->AddressSpace()), - ShaderIOKind::kModuleScopeVar}); - } - } - - if (stage != Function::PipelineStage::kUndefined) { - // Shared context for blend_src and location validation - BlendSrcContext input_ctx{func->Stage(), {}, {}, nullptr, IODirection::kInput}; - BlendSrcContext output_ctx{func->Stage(), {}, {}, nullptr, IODirection::kOutput}; - - // First pass: pre-populate location hashes for blend_src. - for (const auto& task : tasks) { - auto& ctx = task.dir == IODirection::kInput ? input_ctx : output_ctx; - WalkTypeAndMembers( - ctx, task.type, task.attr, - [task](BlendSrcContext& c, const core::type::Type*, const IOAttributes& a) { - if (a.blend_src.has_value() && a.location.has_value()) { - c.locations.Add(a.location.value(), task.anchor); - } - }); - } - - // Second pass: validate blend_src usages. - for (const auto& task : tasks) { - auto& ctx = task.dir == IODirection::kInput ? input_ctx : output_ctx; - CheckBlendSrc(ctx, task.anchor, task.type, task.attr); - } - - if (!output_ctx.blend_srcs.IsEmpty()) { - if (output_ctx.blend_srcs.Count() != 2) { - AddError(func) << "if any @blend_src is used on an output, then @blend_src(0) and " - "@blend_src(1) must be used"; - } - } - - // Third pass: validate all non-blend_src location usages. - for (const auto& task : tasks) { - if (task.dir == IODirection::kInput) { - CheckLocation(input_ctx.locations, task.anchor, task.attr, func->Stage(), task.type, - task.dir); - } else if (task.dir == IODirection::kOutput) { - CheckLocation(output_ctx.locations, task.anchor, task.attr, func->Stage(), - task.type, task.dir); - } - } - } - - // Validate all the interpolation usages. - for (const auto& task : tasks) { - CheckInterpolation(task.anchor, task.type, task.attr, stage, task.dir); - } - - if (stage != Function::PipelineStage::kUndefined) { - // Validate all the binding_point usages, and ensure things that require binding_point have - // them. - for (const auto& task : tasks) { - CheckBindingPoint(task.anchor, task.type, task.attr, task.io_kind); - } - } - - IOAttributeContext impl_ctx{.input_builtins = {}, .output_builtins = {}}; - // Validate all remaining attributes on IO objects - for (const auto& task : tasks) { - ValidateIOAttributesImpl(impl_ctx, task.anchor, task.type, task.attr, stage, task.dir, - task.io_kind); - } -} - -void Validator::ValidateIOAttributesImpl(IOAttributeContext& ctx, - const CastableBase* msg_anchor, - const core::type::Type* ty, - const IOAttributes& attr, - Function::PipelineStage stage, - IODirection dir, - ShaderIOKind io_kind) { - bool skip_builtins = capabilities_.Contains(Capability::kLoosenValidationForShaderIO) && - io_kind == ShaderIOKind::kModuleScopeVar; - const IOAttributeUsage usage = IOAttributeUsageFor(stage, dir); - WalkTypeAndMembers( - *this, ty, attr, - [&ctx, msg_anchor, usage, io_kind, skip_builtins, dir]( - Validator& v, const core::type::Type* t, const IOAttributes& a) { - const auto checkers = IOAttributeCheckersFor(a, skip_builtins); - if (checkers.IsEmpty()) { - return; - } - - if (a.builtin.has_value() && !skip_builtins) { - const auto& builtin = a.builtin.value(); - - uint32_t count = 0; - switch (dir) { - case IODirection::kInput: - count = ++(ctx.input_builtins.GetOrAddZeroEntry(builtin).value); - break; - case IODirection::kOutput: - count = ++(ctx.output_builtins.GetOrAddZeroEntry(builtin).value); - break; - default: - // This shouldn't ever happen, but this will get caught later in the - // checker, so just ignoring - break; - } - if (v.capabilities_.Contains(Capability::kAllowClipDistancesOnF32ScalarAndVector) && - builtin == BuiltinValue::kClipDistances) { - if (count > 2) { - v.AddError(msg_anchor) - << "too many instances of builtin 'clip_distances' on entry point " - << ToString(dir) - << ", only two allowed with 'kAllowClipDistancesOnF32ScalarAndVector' " - "capability enabled"; - } - } else { - if (count > 1) { - v.AddError(msg_anchor) - << "duplicate instance of builtin '" << ToString(builtin) - << "' on entry point " << ToString(dir) - << ", must be unique per entry point i/o direction"; - } - } - } - - auto failed = tint::Hashset(); - - if (usage != IOAttributeUsage::kUndefinedUsage) { - for (const auto* checker : checkers) { - if (!checker->valid_usages.Contains(usage)) { - failed.Add(checker); - - std::stringstream msg; - msg << ToString(checker->kind) << " IO attributes cannot be declared for a " - << ToString(usage) << ". "; - if (checker->valid_usages.Size() == 1) { - const auto& u = *checker->valid_usages.begin(); - msg << "They can only be used for a " << ToString(u) << "."; - } else { - msg << "They can only be used for " << ToString(checker->valid_usages); - } - v.AddError(msg_anchor) << msg.str(); - } - } - } - - for (const auto& checker : checkers) { - if (failed.Contains(checker)) { - continue; - } - - if (!checker->valid_io_kinds.Contains(io_kind)) { - failed.Add(checker); - - std::stringstream msg; - msg << ToString(checker->kind) << " IO attributes cannot be declared on a " - << ToString(io_kind) << ". "; - if (checker->valid_io_kinds.Size() == 1) { - const auto& k = *checker->valid_io_kinds.begin(); - msg << "They can only be used on a " << ToString(k) << "."; - } else { - msg << "They can only be used on " << ToString(checker->valid_io_kinds); - } - v.AddError(msg_anchor) << msg.str(); - } - } - - for (const auto& checker : checkers) { - if (failed.Contains(checker)) { - continue; - } - - if (!checker->type_check(t, v.capabilities_)) { - failed.Add(checker); - v.AddError(msg_anchor) << ToString(checker->kind) << " " << checker->type_error; - } - } - - for (const auto& checker : checkers) { - if (failed.Contains(checker)) { - continue; - } - - if (auto res = checker->check(t, a, v.capabilities_, usage); res != Success) { - failed.Add(checker); - v.AddError(msg_anchor) << res.Failure(); - } - } - }); -} - -void Validator::CheckFrontFacingIfBool(const CastableBase* msg_anchor, - const IOAttributes& attr, - const core::type::Type* ty, - const std::string& err) { - if (ty->Is() && attr.builtin != BuiltinValue::kFrontFacing) { - AddError(msg_anchor) << err; - } -} - -void Validator::CheckNotBool(const CastableBase* msg_anchor, - const core::type::Type* ty, - const std::string& err) { - if (ty->Is()) { - AddError(msg_anchor) << err; - } -} - -void Validator::CheckWorkgroupSize(const Function* func) { - if (!func->IsCompute()) { - if (func->WorkgroupSize().has_value()) { - AddError(func) << "@workgroup_size only valid on compute entry point"; - } - return; - } - - if (!func->WorkgroupSize().has_value()) { - AddError(func) << "compute entry point requires @workgroup_size"; - return; - } - - auto workgroup_sizes = func->WorkgroupSize().value(); - // The number parameters cannot be checked here, since it is stored internally as a 3 element - // array, so will always have 3 elements at this point. - TINT_ASSERT(workgroup_sizes.size() == 3); - - uint64_t total_size = 1; - - std::optional sizes_ty; - for (auto* size : workgroup_sizes) { - if (!size || !size->Type()) { - AddError(func) << "a @workgroup_size param is undefined or missing a type"; - return; - } - - auto* ty = size->Type(); - if (!ty->IsAnyOf()) { - AddError(func) << "@workgroup_size params must be an 'i32' or 'u32', received " - << NameOf(ty); - return; - } - - if (!sizes_ty.has_value()) { - sizes_ty = ty; - } - - if (sizes_ty != ty) { - AddError(func) << "@workgroup_size params must be all 'i32's or all 'u32's"; - return; - } - - if (auto* c = size->As()) { - if (c->Value()->ValueAs() <= 0) { - AddError(func) << "@workgroup_size params must be greater than 0"; - return; - } - total_size *= c->Value()->ValueAs(); - - constexpr uint64_t kMaxGridSize = 0xffffffff; - if (total_size > kMaxGridSize) { - AddError(func) << "workgroup grid size cannot exceed 0x" << std::hex - << kMaxGridSize; - } - continue; - } - - if (!capabilities_.Contains(Capability::kAllowOverrides)) { - AddError(func) << "@workgroup_size param is not a constant value, and IR capability " - "'kAllowOverrides' is not set"; - return; - } - - if (auto* r = size->As()) { - if (!r->Instruction()) { - AddError(func) << "instruction for @workgroup_size param is not defined"; - return; - } - - if (r->Instruction()->Block() != mod_.root_block) { - AddError(func) << "@workgroup_size param defined by non-module scope value"; - return; - } - - // Since above, it is already checked if the value is in the root block, it is assumed - // to be pipeline creatable here, i.e. const/override or derived from consts and - // overrides. - // If that is not true, that indicates an issue in CheckRootBlock(). - continue; - } - - AddError(func) << "@workgroup_size must be an InstructionResult or a Constant"; - } -} - -void Validator::CheckSubgroupSize(const Function* func) { - // @subgroup_size is optional - if (!func->SubgroupSize().has_value()) { - return; - } - - if (!func->IsCompute()) { - AddError(func) << "@subgroup_size only valid on compute entry point"; - return; - } - - auto subgroup_size = func->SubgroupSize().value(); - if (subgroup_size == nullptr) { - AddError(func) << "a @subgroup_size param must have a value"; - return; - } - - if (!subgroup_size->Type()) { - AddError(func) << "a @subgroup_size param is missing a type"; - return; - } - - auto* ty = subgroup_size->Type(); - if (!ty->IsAnyOf()) { - AddError(func) << "@subgroup_size param must be an 'i32' or 'u32', received " << NameOf(ty); - return; - } - - if (auto* c = subgroup_size->As()) { - int64_t value = c->Value()->ValueAs(); - if (value <= 0) { - AddError(func) << "@subgroup_size param must be greater than 0"; - return; - } - - if (!IsPowerOfTwo(value)) { - AddError(func) << "@subgroup_size param must be a power of 2"; - return; - } - - return; - } - - if (!capabilities_.Contains(Capability::kAllowOverrides)) { - AddError(func) << "@subgroup_size param is not a constant value, and IR capability " - "'kAllowOverrides' is not set"; - return; - } - - if (auto* r = subgroup_size->As()) { - if (!r->Instruction()) { - AddError(func) << "instruction for @subgroup_size param is not defined"; - return; - } - - if (r->Instruction()->Block() != mod_.root_block) { - AddError(func) << "@subgroup_size param defined by non-module scope value"; - return; - } - - if (r->Instruction()->Is()) { - return; - } - } - - AddError(func) << "@subgroup_size must be an InstructionResult or a Constant"; -} - -void Validator::CheckPositionPresentForVertexOutput(const Function* ep) { - if (IsPositionPresent(ep->ReturnAttributes(), ep->ReturnType())) { - return; - } - - for (const auto& var : referenced_module_vars_.TransitiveReferences(ep)) { - const auto* ty = var->Result()->Type()->UnwrapPtrOrRef(); - if (!ty) { - continue; - } - - const auto attr = var->Attributes(); - if (IsPositionPresent(attr, ty)) { - return; - } - } - AddError(ep) << "position must be declared for vertex entry point output"; -} - -void Validator::ProcessTasks() { - while (!tasks_.IsEmpty()) { - tasks_.Pop()(); - } -} - -void Validator::QueueBlock(const Block* blk) { - tasks_.Push([this] { EndBlock(); }); - tasks_.Push([this, blk] { BeginBlock(blk); }); -} - -void Validator::BeginBlock(const Block* blk) { - scope_stack_.Push(); - block_stack_.Push(blk); - - if (auto* mb = blk->As()) { - for (auto* param : mb->Params()) { - if (!param->Alive()) { - AddError(param) << "destroyed parameter found in block parameter list"; - return; - } - if (!param->Block()) { - AddError(param) << "block parameter has nullptr parent block"; - return; - } else if (param->Block() != mb) { - AddError(param) << "block parameter has incorrect parent block"; - AddNote(param->Block()) << "parent block declared here"; - return; - } - - // References not allowed on block parameters even with Capability::kAllowRefTypes. - CheckType( - param->Type(), [&]() -> diag::Diagnostic& { return AddError(param); }, - Capabilities{Capability::kAllowRefTypes}); - - if (param->Type()->Is()) { - AddError(param) << "block parameter type cannot be void"; - } - - scope_stack_.Add(param); - } - } - - if (!blk->Terminator()) { - AddError(blk) << "block does not end in a terminator instruction"; - } - - // Validate the instructions w.r.t. the parent block - for (auto* inst : *blk) { - if (inst->Block() != blk) { - AddError(inst) << "block instruction does not have same block as parent"; - AddNote(blk) << "in block"; - } - } - - // Enqueue validation of the instructions of the block - if (!blk->IsEmpty()) { - QueueInstructions(blk->Instructions()); - } -} - -void Validator::EndBlock() { - scope_stack_.Pop(); - block_stack_.Pop(); -} - -void Validator::QueueInstructions(const Instruction* inst) { - if (diagnostics_.ContainsErrors()) { - return; - } - - tasks_.Push([this, inst] { - // Tasks are processed LIFO, so push the next instruction to the stack before checking the - // current instruction, which may need to add more blocks to the stack itself. - if (inst->next) { - QueueInstructions(inst->next); - } - CheckInstruction(inst); - }); -} - -void Validator::CheckInstruction(const Instruction* inst) { - visited_instructions_.Add(inst); - if (!inst->Alive()) { - AddError(inst) << "destroyed instruction found in instruction list"; - return; - } - - Capabilities allowed_types{}; - if (inst->Is()) { - allowed_types.Add(Capability::kAllow64BitIntegers); - } - - auto results = inst->Results(); - for (size_t i = 0; i < results.Length(); ++i) { - auto* res = results[i]; - if (!res) { - continue; - } - - CheckType( - res->Type(), [&]() -> diag::Diagnostic& { return AddResultError(inst, i); }, {}, - allowed_types); - } - - auto ops = inst->Operands(); - for (size_t i = 0; i < ops.Length(); ++i) { - auto* op = ops[i]; - if (!op) { - continue; - } - - CheckType( - op->Type(), [&]() -> diag::Diagnostic& { return AddError(inst, i); }, {}, - allowed_types); - } - - tint::Switch( - inst, // - [&](const Access* a) { CheckAccess(a); }, // - [&](const Binary* b) { CheckBinary(b); }, // - [&](const Call* c) { CheckCall(c); }, // - [&](const If* if_) { CheckIf(if_); }, // - [&](const Let* let) { CheckLet(let); }, // - [&](const Load* load) { CheckLoad(load); }, // - [&](const LoadVectorElement* l) { CheckLoadVectorElement(l); }, // - [&](const Loop* l) { CheckLoop(l); }, // - [&](const Phony* p) { CheckPhony(p); }, // - [&](const Store* s) { CheckStore(s); }, // - [&](const StoreVectorElement* s) { CheckStoreVectorElement(s); }, // - [&](const Switch* s) { CheckSwitch(s); }, // - [&](const Swizzle* s) { CheckSwizzle(s); }, // - [&](const Terminator* b) { CheckTerminator(b); }, // - [&](const Unary* u) { CheckUnary(u); }, // - [&](const Override* o) { CheckOverride(o); }, // - [&](const Var* var) { CheckVar(var); }, // - [&](const Default) { AddError(inst) << "missing validation"; }); - - for (auto* result : results) { - scope_stack_.Add(result); - } -} - -void Validator::CheckOverride(const Override* o) { - // Intentionally not checking operands, since Override may have a null operand - if (!CheckResults(o, Override::kNumResults)) { - return; - } - - if (o->OverrideId().has_value()) { - if (!seen_override_ids_.Add(o->OverrideId().value())) { - AddError(o) << "duplicate override id encountered: " << o->OverrideId().value().value; - return; - } - } - - if (!o->Result()->Type()->IsScalar()) { - AddError(o) << "override type " << NameOf(o->Result()->Type()) << " is not a scalar"; - return; - } - - if (o->Initializer()) { - if (!CheckOperand(o, ir::Var::kInitializerOperandOffset)) { - return; - } - if (o->Initializer()->Type() != o->Result()->Type()) { - AddError(o) << "override type " << NameOf(o->Result()->Type()) - << " does not match initializer type " << NameOf(o->Initializer()->Type()); - return; - } - } - - if (!o->OverrideId().has_value() && (o->Initializer() == nullptr)) { - AddError(o) << "must have an id or an initializer"; - return; - } -} - -void Validator::CheckVar(const Var* var) { - if (!CheckResultsAndOperands(var, Var::kNumResults, Var::kNumOperands)) { - return; - } - - auto* result_type = var->Result()->Type(); - auto* mv = result_type->As(); - if (!mv) { - AddError(var) << "result type " << NameOf(result_type) - << " must be a pointer or a reference"; - return; - } - - if (var->Block() != mod_.root_block && mv->AddressSpace() != AddressSpace::kFunction) { - if (!capabilities_.Contains(Capability::kMslAllowEntryPointInterface) || - mv->AddressSpace() != AddressSpace::kPrivate) { - AddError(var) << "vars in a function scope must be in the 'function' address space"; - return; - } - } - - if (ContainsAtomic(mv->StoreType())) { - if (mv->AddressSpace() == AddressSpace::kStorage) { - if (mv->Access() != core::Access::kReadWrite) { - AddError(var) - << "atomic variables in 'storage' address space must have 'read_write' " - "access mode"; - return; - } - } else if (mv->AddressSpace() != AddressSpace::kWorkgroup) { - AddError(var) - << "atomic variables must be in the 'workgroup' or 'storage' address space"; - return; - } - } - - // Check that initializer and result type match - if (var->Initializer()) { - if (mv->AddressSpace() != AddressSpace::kFunction && - mv->AddressSpace() != AddressSpace::kPrivate && - mv->AddressSpace() != AddressSpace::kOut) { - AddError(var) << "only variables in the function, private, or __out address space may " - "be initialized"; - return; - } - - if (!CheckOperand(var, ir::Var::kInitializerOperandOffset)) { - return; - } - - if (var->Initializer()->Type() != result_type->UnwrapPtrOrRef()) { - AddError(var) << "initializer type " << NameOf(var->Initializer()->Type()) - << " does not match store type " << NameOf(result_type->UnwrapPtrOrRef()); - return; - } - } - - CheckBindingPoint(var, var->Result(0)->Type(), var->Attributes(), - ShaderIOKind::kModuleScopeVar); - - if (var->Block() == mod_.root_block && mv->AddressSpace() == AddressSpace::kFunction) { - AddError(var) << "vars in the 'function' address space must be in a function scope"; - return; - } - - if (mv->AddressSpace() == AddressSpace::kWorkgroup) { - if (auto* ary = result_type->UnwrapPtr()->As()) { - if (auto* count = ary->Count()->As()) { - if (!scope_stack_.Contains(count->value)) { - AddError(var) << NameOf(count->value) << " is not in scope"; - } - } - } - } - - if (mv->AddressSpace() == AddressSpace::kStorage) { - if (mv->StoreType() && !mv->StoreType()->IsHostShareable()) { - AddError(var) << "vars in the 'storage' address space must be host-shareable"; - return; - } - if (mv->Access() != core::Access::kReadWrite && mv->Access() != core::Access::kRead) { - AddError(var) - << "vars in the 'storage' address space must have access 'read' or 'read-write'"; - return; - } - } - - if (mv->AddressSpace() == AddressSpace::kUniform) { - if (!(mv->StoreType()->IsConstructible() || mv->StoreType()->Is()) || - !mv->StoreType()->IsHostShareable()) { - AddError(var) << "vars in the 'uniform' address space must be host-shareable and " - "constructible or a buffer"; - return; - } - } - - if (mv->AddressSpace() == AddressSpace::kImmediate) { - if (mv->StoreType() && !mv->StoreType()->IsHostShareable()) { - AddError(var) << "vars in the 'immediate' address space must be host-shareable"; - return; - } - } - - if (var->InputAttachmentIndex().has_value()) { - if (mv->AddressSpace() != AddressSpace::kHandle) { - AddError(var) << "'@input_attachment_index' is not valid for non-handle var"; - return; - } - if (!capabilities_.Contains(Capability::kAllowAnyInputAttachmentIndexType) && - !mv->UnwrapPtrOrRef()->Is()) { - AddError(var) - << "'@input_attachment_index' is only valid for 'input_attachment' type var"; - return; - } - } - - if (var->Block() == mod_.root_block) { - if (mv->AddressSpace() == AddressSpace::kIn || mv->AddressSpace() == AddressSpace::kOut) { - ValidateShaderIOAnnotations(var, var->Result()->Type(), var->BindingPoint(), - var->Attributes(), ShaderIOKind::kModuleScopeVar); - } - } - - if (mv->AddressSpace() == core::AddressSpace::kPixelLocal) { - if (var->Block() == mod_.root_block) { - if (!mv->StoreType()->Is()) { - AddError(var) << "pixel_local var must be of type struct"; - return; - } - } - } -} - -void Validator::CheckBlendSrc(BlendSrcContext& ctx, - const CastableBase* target, - const core::type::Type* ty, - const IOAttributes& attr) { - if (attr.blend_src.has_value()) { - if (!capabilities_.Contains(Capability::kLoosenValidationForShaderIO)) { - AddError(target) << "blend_src cannot be used on non-struct-member types"; - } - CheckBlendSrcImpl(ctx, target, ty, attr); - } - - if (auto* s = ty->As()) { - if (s->Members().Any([](auto* m) { return m->Attributes().blend_src.has_value(); })) { - auto location_count = 0u; - for (const auto* mem : s->Members()) { - auto& mem_attr = mem->Attributes(); - if (mem_attr.location.has_value()) { - location_count++; - } - CheckBlendSrcImpl(ctx, target, mem->Type(), mem_attr); - } - - if (location_count != 2) { - AddError(target) - << "structs with blend_src members must have exactly 2 members with " - "location annotations"; - } - return; - } - } - - // Reject blend_src on nested members - if (!capabilities_.Contains(Capability::kLoosenValidationForShaderIO)) { - WalkTypeAndMembers( - ctx, ty, attr, - [&target, this](BlendSrcContext&, const core::type::Type*, const IOAttributes& a) { - if (a.blend_src.has_value()) { - AddError(target) - << "blend_src cannot be used on members of non-top level structs"; - } - }); - } -} - -void Validator::CheckBlendSrcImpl(BlendSrcContext& ctx, - const CastableBase* target, - const core::type::Type* ty, - const IOAttributes& attr) { - if (!attr.blend_src.has_value()) { - return; - } - - auto bs_val = attr.blend_src.value(); - if (bs_val != 0 && bs_val != 1) { - AddError(target) << "blend_src value must be 0 or 1"; - } - if (!ctx.blend_srcs.Add(bs_val)) { - AddError(target) << "duplicate blend_src(" << bs_val << ") on entry point " - << ToString(ctx.dir); - } - - if (ctx.dir != IODirection::kOutput || ctx.stage != Function::PipelineStage::kFragment) { - AddError(target) << "blend_src can only be used on fragment shader outputs"; - return; - } - if (!attr.location.has_value() || attr.location.value() != 0) { - AddError(target) << "struct members with blend_src must be located at 0"; - } - - if (!ctx.blend_src_type) { - if (!ty->IsNumericScalarOrVector()) { - AddError(target) << "blend_src must be a numeric scalar or vector, but has type " - << ty->FriendlyName(); - } - ctx.blend_src_type = ty; - } else if (ctx.blend_src_type != ty) { - AddError(target) << "blend_src type " << ty->FriendlyName() - << " does not match other blend_src type " - << ctx.blend_src_type->FriendlyName(); - } -} - -void Validator::CheckLocation(Hashmap& locations, - const CastableBase* target, - const IOAttributes& attr, - const Function::PipelineStage stage, - const core::type::Type* type, - const IODirection dir) { - struct WalkContext { - Validator* validator; - Hashmap& locations; - const CastableBase* target; - const Function::PipelineStage stage; - const IODirection dir; - }; - WalkContext ctx{this, locations, target, stage, dir}; - - WalkTypeAndMembers( - ctx, type, attr, - [](WalkContext& context, const core::type::Type* ty, const IOAttributes& attribute) { - if (ty->Is()) { - return; - } - - if (attribute.blend_src) { - // locations associated with a blend_src usage should already be - // pre-populated in locations - return; - } - - if (attribute.location.has_value()) { - if (context.stage == Function::PipelineStage::kCompute && - context.dir == IODirection::kInput) { - context.validator->AddError(context.target) - << "location attribute is not valid for compute shader inputs"; - } - - auto loc = attribute.location.value(); - if (const auto conflict = context.locations.Get(loc)) { - context.validator->AddError(context.target) - << "duplicate location(" << loc << ") on entry point " - << ToString(context.dir); - context.validator->AddDeclarationNote(*conflict.value); - } else { - context.locations.Add(loc, context.target); - } - } - }); -} - -void Validator::CheckInterpolation(const CastableBase* anchor, - const core::type::Type* ty, - const IOAttributes& attr, - const Function::PipelineStage stage, - const IODirection dir) { - bool ctx = false; - - WalkTypeAndMembers( - ctx, ty, attr, - [this, anchor, stage, dir](bool& in_location_composite, const core::type::Type* t, - const IOAttributes& a) { - bool has_location = a.location.has_value() || in_location_composite; - if (!has_location) { - if (auto* str = t->As()) { - has_location |= str->Members().All( - [](const auto* mem) { return mem->Attributes().location.has_value(); }); - } - } - - if (a.interpolation.has_value()) { - has_location |= (capabilities_.Contains(Capability::kLoosenValidationForShaderIO) && - a.builtin.has_value()); - - if (!capabilities_.Contains(Capability::kAllowLocationForNumericElements) && - t->As()) { - AddError(anchor) << "interpolation cannot be applied to a struct without " - "'kAllowLocationForNumericElements' capability"; - } - - if (t->IsIntegerScalar()) { - if (a.interpolation.value().type != InterpolationType::kFlat) { - AddError(anchor) - << "interpolation attribute type must be flat for integral types"; - } - } - - if (!has_location) { - if (!capabilities_.Contains(Capability::kLoosenValidationForShaderIO)) { - AddError(anchor) << "interpolation attribute requires a location attribute"; - } else { - AddError(anchor) << "interpolation attribute requires a location attribute " - "(or location-like shader I/O annotation)"; - } - } - } else if (has_location && t->IsIntegerScalarOrVector()) { - // Integral vertex outputs and fragment inputs require flat interpolation. - const bool needs_flat = - (stage == Function::PipelineStage::kVertex && dir == IODirection::kOutput) || - (stage == Function::PipelineStage::kFragment && dir == IODirection::kInput); - if (needs_flat) { - AddError(anchor) << "integral user-defined inputs and outputs must have an " - "@interpolate(flat) attribute"; - } - } - - if (t->IsAnyOf()) { - in_location_composite |= a.location.has_value(); - } - }); -} - -void Validator::CheckBindingPoint(const CastableBase* anchor, - const core::type::Type* ty, - const IOAttributes& attr, - const ShaderIOKind& io_kind) { - const auto& binding_point = attr.binding_point; - auto address_space = AddressSpace::kUndefined; - if (const auto* mv = ty->As()) { - address_space = mv->AddressSpace(); - } else { - // ModuleScopeVars transform in MSL backends unwraps pointers to handles - if (ty->IsHandle()) { - address_space = AddressSpace::kHandle; - } - } - - if (binding_point.has_value() && io_kind != ShaderIOKind::kModuleScopeVar && - !capabilities_.Contains(Capability::kMslAllowEntryPointInterface)) { - AddError(anchor) << "binding_points are only valid on resource variables"; - } - - switch (address_space) { - case AddressSpace::kHandle: - if (!capabilities_.Contains(Capability::kAllowHandleVarsWithoutBindings)) { - if (!binding_point.has_value()) { - AddError(anchor) - << "a " << ToString(address_space) << " resource requires a binding point"; - } - } - break; - case AddressSpace::kStorage: - case AddressSpace::kUniform: - if (!binding_point.has_value()) { - AddError(anchor) << "a " << ToString(address_space) - << " resource requires a binding point"; - } - break; - default: - if (binding_point.has_value()) { - AddError(anchor) << "a " << ToString(address_space) - << " non-resource cannot have a binding point"; - } - break; - } -} - -void Validator::ValidateShaderIOAnnotations(const CastableBase* msg_anchor, - const core::type::Type* ty, - const std::optional& binding_point, - const IOAttributes& attr, - ShaderIOKind kind) { - EnumSet annotations; - - // Since there is no entries in the set at this point, this should never fail. - TINT_ASSERT(AddIOAnnotationsFromIOAttributes(annotations, attr) == Success); - - if (binding_point.has_value()) { - annotations.Add(IOAnnotation::kBindingPoint); - } - - if (auto* mv = ty->As()) { - if (mv->AddressSpace() == AddressSpace::kWorkgroup) { - annotations.Add(IOAnnotation::kWorkgroup); - } - } - - if (ty->Is()) { - if (!annotations.Empty()) { - AddError(msg_anchor) << ToString(kind) << " with void type should never be annotated"; - } - return; // Early return because later rules assume non-void types. - } - - if (attr.location.has_value()) { - if (capabilities_.Contains(Capability::kAllowLocationForNumericElements)) { - std::function is_numeric = - [&is_numeric](const core::type::Type* t) -> bool { - t = t->UnwrapPtrOrRef(); - bool result = false; - tint::Switch( - t, - [&](const core::type::Struct* s) { - for (auto* m : s->Members()) { - if (!is_numeric(m->Type())) { - return; - } - } - result = true; - }, - [&](Default) { - auto* e = t->DeepestElement()->UnwrapPtrOrRef(); - tint::Switch( - e, [&](const core::type::Struct* s) { result = is_numeric(s); }, - [&](Default) { result = e->IsNumericScalarOrVector(); }); - }); - return result; - }; - if (!is_numeric(ty)) { - AddError(msg_anchor) - << ToString(kind) - << " with a location attribute must contain only numeric elements " - << ty->FriendlyName(); - return; - } - } else { - if (!ty->UnwrapPtrOrRef()->IsNumericScalarOrVector()) { - AddError(msg_anchor) << ToString(kind) - << " with a location attribute must be a numeric scalar or " - "vector, but has type " - << ty->FriendlyName(); - return; - } - } - } - - if (auto* ty_struct = ty->UnwrapPtrOrRef()->As()) { - for (const auto* mem : ty_struct->Members()) { - EnumSet mem_annotations = annotations; - auto add_result = AddIOAnnotationsFromIOAttributes(mem_annotations, mem->Attributes()); - if (add_result != Success) { - AddError(msg_anchor) - << ToString(kind) - << " struct member has same IO annotation, as top-level struct, '" - << ToString(add_result.Failure()) << "'"; - return; - } - - if (mem->Attributes().location.has_value()) { - if (capabilities_.Contains(Capability::kAllowLocationForNumericElements)) { - if (!mem->Type()->UnwrapPtrOrRef()->IsNumericScalarOrVector() && - !mem->Type()->UnwrapPtrOrRef()->Is()) { - AddError(msg_anchor) - << ToString(kind) - << " struct member with a location attribute must be a numeric scalar, " - "a numeric vector or a struct, but has type " - << mem->Type()->FriendlyName(); - return; - } - } else { - if (!mem->Type()->UnwrapPtrOrRef()->IsNumericScalarOrVector()) { - AddError(msg_anchor) << ToString(kind) - << " struct member with a location attribute must be " - "a numeric scalar or vector, but has type " - << mem->Type()->FriendlyName(); - return; - } - } - } - - if (capabilities_.Contains(Capability::kMslAllowEntryPointInterface)) { - if (auto* mv = mem->Type()->As()) { - if (mv->AddressSpace() == AddressSpace::kWorkgroup) { - mem_annotations.Add(IOAnnotation::kWorkgroup); - } - } - } - - if (mem_annotations.Empty()) { - AddError(msg_anchor) << ToString(kind) - << " struct members must have at least one IO annotation, " - "e.g. a binding point, a location, etc"; - } else if (mem_annotations.Size() > 1) { - AddError(msg_anchor) - << ToString(kind) << " struct member has more than one IO annotation, " - << ToString(mem_annotations); - } - } - } else { - if (annotations.Empty()) { - if (!(capabilities_.Contains(Capability::kAllowUnannotatedModuleIOVariables) && - kind == ShaderIOKind::kModuleScopeVar)) { - AddError(msg_anchor) << ToString(kind) - << " must have at least one IO annotation, e.g. a binding " - "point, a location, etc"; - } - } else if (annotations.Size() > 1) { - AddError(msg_anchor) << ToString(kind) << " has more than one IO annotation, " - << ToString(annotations); - } - } -} - -void Validator::CheckLet(const Let* l) { - if (!CheckResultsAndOperands(l, Let::kNumResults, Let::kNumOperands)) { - return; - } - - auto* value_ty = l->Value()->Type(); - if (capabilities_.Contains(Capability::kAllowAnyLetType)) { - if (value_ty->Is()) { - AddError(l) << "value type cannot be void"; - } - } else { - if (!value_ty->IsConstructible() && !value_ty->Is()) { - AddError(l) << "value type, " << NameOf(value_ty) - << ", must be concrete constructible type or a pointer type"; - } - } - - auto* result_ty = l->Result()->Type(); - if (!capabilities_.Contains(Capability::kAllowAnyLetType)) { - if (auto* ptr = result_ty->As()) { - if (ptr->AddressSpace() == AddressSpace::kHandle && - !capabilities_.Contains(Capability::kAllowPointerToHandle)) { - AddError(l) << "handle pointer cannot be captured in a let"; - } - } else if (!result_ty->IsConstructible()) { - AddError(l) << "result type, " << NameOf(result_ty) - << ", must be concrete constructible type or a pointer type"; - } - } - - if (value_ty != result_ty) { - AddError(l) << "result type " << NameOf(l->Result()->Type()) - << " does not match value type " << NameOf(l->Value()->Type()); - } -} - -void Validator::CheckCall(const Call* call) { - tint::Switch( - call, // - [&](const Bitcast* b) { CheckBitcast(b); }, // - [&](const BuiltinCall* c) { CheckBuiltinCall(c); }, // - [&](const MemberBuiltinCall* c) { CheckMemberBuiltinCall(c); }, // - [&](const Construct* c) { CheckConstruct(c); }, // - [&](const Convert* c) { CheckConvert(c); }, // - [&](const Discard* d) { // - stage_restricted_instructions_.Add( - d, SupportedStages{Function::PipelineStage::kFragment}); // - CheckDiscard(d); // - }, // - [&](const UserCall* c) { // - if (c->Target()) { // - auto calls = // - user_func_calls_.GetOr(c->Target(), // - Hashset{}); // - calls.Add(c); // - user_func_calls_.Replace(c->Target(), calls); // - } - CheckUserCall(c); - }, - [&](Default) { - // Validation of custom IR instructions - }); -} - -void Validator::CheckBitcast(const Bitcast* bitcast) { - if (!CheckResultsAndOperands(bitcast, Bitcast::kNumResults, Bitcast::kNumOperands)) { - return; - } - - CheckBitcastTypes(bitcast); -} - -void Validator::CheckBitcastTypes(const Bitcast* bitcast) { - // Caller is responsible for checking results and operands - const auto* val_type = bitcast->Operand(Bitcast::kValueOperandOffset)->Type(); - const auto* result_type = bitcast->Result()->Type(); - - const auto add_error = [&]() { - AddError(bitcast) << "bitcast is not defined for " << NameOf(val_type) << " -> " - << NameOf(result_type); - }; - - // Check that there exists an overload for the provided types - if (val_type->IsAnyOf()) { - // S, where S is i32, u32, or f32 - // S -> S, identity and reinterpretation - if (result_type->IsAnyOf()) { - return; - } - - // S -> vec2 - if (auto* vec_type = result_type->As()) { - auto elements = vec_type->Elements(); - if (elements.count == 2 && IsAnyOf(elements.type)) { - return; - } - } - } else if (val_type->IsAnyOf()) { - // S, where S is f16 or u16 - // S -> S, identity and reinterpretation - if (result_type->IsAnyOf()) { - return; - } - } else if (val_type->Is()) { - auto val_elements = val_type->Elements(); - if (!val_elements.type) { - // Malformed vector - add_error(); - return; - } - - std::optional result_elements; - if (result_type->As()) { - result_elements = result_type->Elements(); - if (!result_elements->type) { - // Malformed vector - add_error(); - return; - } - } - - // atomic vec2u support vec2u to u64 bitcast required - if (val_elements.count == 2 && val_elements.type->Is() && - result_type->Is()) { - return; // assume backend supported - } - - if (val_elements.type->IsAnyOf()) { - // vecN, where S is i32, u32, or f32 - // vecN -> vecN, identity and reinterpretation cases - if (result_elements.has_value() && val_elements.count == result_elements->count && - result_elements->type - ->IsAnyOf()) { - return; - } - - // vec2 -> vec4 - if (val_elements.count == 2) { - if (result_elements.has_value() && result_elements->count == 4 && - result_elements->type->IsAnyOf()) { - return; - } - } - } else if (val_elements.type->IsAnyOf()) { - if (result_elements.has_value()) { - if (result_elements->type->IsAnyOf()) { - // vecN -> vecN, identity - if (val_elements.count == result_elements->count) { - return; - } - } else { - // vec4 -> vec2, where S is i32, u32, or f32 - if (val_elements.count == 4 && result_elements->count == 2 && - result_elements->type - ->IsAnyOf()) { - return; - } - } - } else { - // vec2 -> i32, u32, or f32 - if (val_elements.count == 2 && - result_type->IsAnyOf()) { - return; - } - } - } - } - - // No matching case for val and result type combination - add_error(); -} - -void Validator::CheckBuiltinCall(const BuiltinCall* call) { - // This check cannot be more precise, since until intrinsic lookup below, it is unknown what - // number of operands are expected, but still need to enforce things are in scope, - // have types, etc. - if (!CheckResults(call, BuiltinCall::kNumResults) || !CheckOperands(call)) { - return; - } - - // CheckOperands above ensures that all args are non-null and have a valid type - auto args = Transform<8>(call->Args(), [&](const ir::Value* v) { return v->Type(); }); - - intrinsic::Context context{ - call->TableData(), - type_mgr_, - symbols_, - }; - - auto builtin = core::intrinsic::LookupFn(context, call->FriendlyName().c_str(), call->FuncId(), - call->ExplicitTemplateParams(), args, - core::EvaluationStage::kRuntime); - if (builtin != Success) { - AddError(call) << builtin.Failure(); - return; - } - - TINT_ASSERT(builtin->return_type); - - if (builtin->return_type != call->Result()->Type()) { - AddError(call) << "call result type " << NameOf(call->Result()->Type()) - << " does not match builtin return type " << NameOf(builtin->return_type); - return; - } - - // Check evaluation stage of parameters that are required to be const-expressions. - for (uint32_t i = 0; i < builtin->parameters.Length(); i++) { - const auto& p = builtin->parameters[i]; - const auto* arg = call->Args()[i]; - if (p.is_const && !arg->Is()) { - AddError(call, BuiltinCall::kArgsOperandOffset + i) - << "the " << style::Variable(p.usage) << " argument must be a constant"; - return; - } - } - - if (auto* bc = call->As()) { - CheckCoreBuiltinCall(bc, builtin.Get()); - } - - // Track the stages that this builtin call is limited to, so that we can check them against the - // entry points that they are used from. - SupportedStages stages; - if (builtin->info->flags.Contains(intrinsic::OverloadFlag::kSupportsComputePipeline)) { - stages.Add(Function::PipelineStage::kCompute); - } - if (builtin->info->flags.Contains(intrinsic::OverloadFlag::kSupportsFragmentPipeline)) { - stages.Add(Function::PipelineStage::kFragment); - } - if (builtin->info->flags.Contains(intrinsic::OverloadFlag::kSupportsVertexPipeline)) { - stages.Add(Function::PipelineStage::kVertex); - } - stage_restricted_instructions_.Add(call, stages); -} - -void Validator::CheckCoreBuiltinCall(const CoreBuiltinCall* call, - const core::intrinsic::Overload& overload) { - auto idx_for_usage = [&](core::ParameterUsage usage) -> std::optional { - for (uint32_t i = 0; i < overload.parameters.Length(); ++i) { - auto& p = overload.parameters[i]; - if (p.usage == usage) { - return int32_t(i); - } - } - return std::nullopt; - }; - - auto check_arg_in_range = [&](core::ParameterUsage usage, int32_t min, int32_t max) { - auto idx_opt = idx_for_usage(usage); - if (!idx_opt.has_value()) { - return; - } - uint32_t idx = idx_opt.value(); - TINT_ASSERT(idx < call->Args().Length()); - - auto* val = call->Args()[idx]; - auto* const_val = val->As(); - TINT_ASSERT(const_val); - auto* cnst = const_val->Value(); - - if (val->Type()->Is()) { - for (size_t i = 0; i < cnst->NumElements(); i++) { - auto value = cnst->Index(i)->ValueAs(); - if (value < min || value > max) { - AddError(call, idx) - << value << " outside range of [" << min << ", " << max << "]"; - return; - } - } - } else { - auto value = cnst->ValueAs(); - if (value < min || value > max) { - AddError(call, idx) << value << " outside range of [" << min << ", " << max << "]"; - return; - } - } - }; - - if (core::IsTexture(call->Func())) { - check_arg_in_range(core::ParameterUsage::kComponent, 0, 3); - check_arg_in_range(core::ParameterUsage::kOffset, -8, 7); - } -} - -void Validator::CheckMemberBuiltinCall(const MemberBuiltinCall* call) { - // This check cannot be more precise, since until intrinsic lookup below, it is unknown what - // number of operands are expected, but still need to enforce things are in scope, - // have types, etc. - if (!CheckResults(call, MemberBuiltinCall::kNumResults) || !CheckOperands(call)) { - return; - } - - auto args = Vector({call->Object()->Type()}); - for (auto* arg : call->Args()) { - args.Push(arg->Type()); - } - intrinsic::Context context{ - call->TableData(), - type_mgr_, - symbols_, - }; - - auto result = core::intrinsic::LookupMemberFn(context, call->FriendlyName().c_str(), - call->FuncId(), call->ExplicitTemplateParams(), - std::move(args), core::EvaluationStage::kRuntime); - if (result != Success) { - AddError(call) << result.Failure(); - return; - } - - if (result->return_type != call->Result()->Type()) { - AddError(call) << "member call result type " << NameOf(call->Result()->Type()) - << " does not match builtin return type " << NameOf(result->return_type); - } -} - -void Validator::CheckConstruct(const Construct* construct) { - if (!CheckResultsAndOperandRange(construct, Construct::kNumResults, Construct::kMinOperands)) { - return; - } - - auto* result_type = construct->Result()->Type(); - - if (!result_type->IsConstructible()) { - // We only allow `construct` to create non-constructible types when they are structures that - // contain pointers and handle types, with the corresponding capability enabled. - if (!(result_type->Is() && - capabilities_.Contains(Capability::kMslAllowEntryPointInterface))) { - AddError(construct) << "type is not constructible"; - return; - } - } - - auto args = construct->Args(); - if (args.IsEmpty()) { - // Zero-value constructors are valid for all constructible types. - return; - } - - auto check_args_match_elements = [&] { - // Check that type type of each argument matches the expected element type of the composite. - for (size_t i = 0; i < args.Length(); i++) { - if (args[i]->Is()) { - continue; - } - auto* expected_type = result_type->Element(static_cast(i)); - if (args[i]->Type() != expected_type) { - AddError(construct, Construct::kArgsOperandOffset + i) - << "type " << NameOf(args[i]->Type()) << " of argument " << i - << " does not match expected type " << NameOf(expected_type); - } - } - }; - - if (result_type->Is()) { - // The only valid non-zero scalar constructor is the identity operation. - if (args.Length() > 1) { - AddError(construct) << "scalar construct must not have more than one argument"; - } - if (args[0]->Type() != result_type) { - AddError(construct, 0u) << "scalar construct argument type " << NameOf(args[0]->Type()) - << " does not match result type " << NameOf(result_type); - } - } else if (auto* sg_mat = result_type->As()) { - if (args.Length() > 1) { - AddError(construct) << "subgroup matrix construct must not have more than 1 argument"; - } else { - // 8-bit integer matrices use 32-bit shader scalar types in WGSL. - // Some backends may support 8-bit integers, in which case they would pass an 8-bit - // type for the constructor value instead. - auto* scalar_ty = sg_mat->Type(); - if (scalar_ty->Is()) { - scalar_ty = type_mgr_.i32(); - } else if (scalar_ty->Is()) { - scalar_ty = type_mgr_.u32(); - } - if (args[0]->Type() != scalar_ty && args[0]->Type() != sg_mat->Type()) { - AddError(construct) - << "subgroup matrix construct argument type " << NameOf(args[0]->Type()) - << " does not match matrix shader scalar type " << NameOf(scalar_ty); - } - } - } else if (auto* vec = result_type->As()) { - auto table = intrinsic::Table(type_mgr_, symbols_); - auto ctor_conv = intrinsic::VectorCtorConv(vec->Width()); - auto arg_types = Transform<4>(args, [&](auto* v) { return v->Type(); }); - auto match = table.Lookup(ctor_conv, Vector{vec->Type()}, std::move(arg_types), - core::EvaluationStage::kConstant); - if (match != Success || vec->Type() != arg_types[0]->DeepestElement()) { - AddError(construct) << "no matching overload for " << vec->FriendlyName() - << " constructor"; - } - } else if (auto* mat = result_type->As()) { - auto table = intrinsic::Table(type_mgr_, symbols_); - auto ctor_conv = intrinsic::MatrixCtorConv(mat->Columns(), mat->Rows()); - auto arg_types = Transform<8>(args, [&](auto* v) { return v->Type(); }); - auto match = table.Lookup(ctor_conv, Vector{mat->Type()}, std::move(arg_types), - core::EvaluationStage::kConstant); - if (match != Success) { - AddError(construct) << "no matching overload for " << mat->FriendlyName() - << " constructor"; - } - } else if (auto* arr = result_type->As()) { - if (args.Length() != arr->ConstantCount()) { - AddError(construct) << "array has " << arr->ConstantCount().value() - << " elements, but construct provides " << args.Length() - << " arguments"; - return; - } - check_args_match_elements(); - } else if (auto* str = As(result_type)) { - auto members = str->Members(); - if (args.Length() != str->Members().Length()) { - AddError(construct) << "structure has " << members.Length() - << " members, but construct provides " << args.Length() - << " arguments"; - return; - } - check_args_match_elements(); - } -} - -void Validator::CheckConvert(const Convert* convert) { - if (!CheckResultsAndOperands(convert, Convert::kNumResults, Convert::kNumOperands)) { - return; - } - - auto* result_type = convert->Result()->Type(); - auto* value_type = convert->Operand(Convert::kValueOperandOffset)->Type(); - - intrinsic::CtorConv conv_ty; - Vector template_type; - tint::Switch( - result_type, // - [&](const core::type::I32*) { conv_ty = intrinsic::CtorConv::kI32; }, // - [&](const core::type::U32*) { conv_ty = intrinsic::CtorConv::kU32; }, // - [&](const core::type::F32*) { conv_ty = intrinsic::CtorConv::kF32; }, // - [&](const core::type::F16*) { conv_ty = intrinsic::CtorConv::kF16; }, // - [&](const core::type::Bool*) { conv_ty = intrinsic::CtorConv::kBool; }, // - [&](const core::type::Vector* v) { - conv_ty = intrinsic::VectorCtorConv(v->Width()); - template_type.Push(v->Type()); - }, - [&](const core::type::Matrix* m) { - conv_ty = intrinsic::MatrixCtorConv(m->Columns(), m->Rows()); - template_type.Push(m->Type()); - }, - [&](Default) { conv_ty = intrinsic::CtorConv::kNone; }); - - if (conv_ty == intrinsic::CtorConv::kNone) { - AddError(convert) << "not defined for result type, " << NameOf(result_type); - return; - } - - auto table = intrinsic::Table(type_mgr_, symbols_); - auto match = - table.Lookup(conv_ty, template_type, Vector{value_type}, core::EvaluationStage::kOverride); - if (match != Success || !match->info->flags.Contains(intrinsic::OverloadFlag::kIsConverter)) { - AddError(convert) << "No defined converter for " << NameOf(value_type) << " -> " - << NameOf(result_type); - return; - } -} - -void Validator::CheckDiscard(const tint::core::ir::Discard* discard) { - CheckResultsAndOperands(discard, Discard::kNumResults, Discard::kNumOperands); -} - -void Validator::CheckUserCall(const UserCall* call) { - if (!CheckResultsAndOperandRange(call, UserCall::kNumResults, UserCall::kMinOperands)) { - return; - } - - if (!call->Target()) { - AddError(call, UserCall::kFunctionOperandOffset) << "target not defined or not a function"; - return; - } - - if (call->Target()->IsEntryPoint()) { - AddError(call, UserCall::kFunctionOperandOffset) - << "call target must not have a pipeline stage"; - } - - if (call->Target()->ReturnType() != call->Result()->Type()) { - AddError(call) << "result type does not match function return type"; - return; - } - - auto args = call->Args(); - auto params = call->Target()->Params(); - if (args.Length() != params.Length()) { - AddError(call, UserCall::kFunctionOperandOffset) - << "function has " << params.Length() << " parameters, but call provides " - << args.Length() << " arguments"; - return; - } - - for (size_t i = 0; i < args.Length(); i++) { - if (args[i]->Type() != params[i]->Type()) { - AddError(call, UserCall::kArgsOperandOffset + i) - << "type " << NameOf(params[i]->Type()) << " of function parameter " << i - << " does not match argument type " << NameOf(args[i]->Type()); - } - } -} - -void Validator::CheckAccess(const Access* a) { - if (!CheckResultsAndOperandRange(a, Access::kNumResults, Access::kMinNumOperands)) { - return; - } - - auto* obj_view = a->Object()->Type()->As(); - auto* ty = obj_view ? obj_view->StoreType() : a->Object()->Type(); - - enum Kind : uint8_t { kPtr, kRef, kValue }; - - auto kind_of = [&](const core::type::Type* type) { - return tint::Switch( - type, // - [&](const core::type::Pointer*) { return kPtr; }, // - [&](const core::type::Reference*) { return kRef; }, // - [&](Default) { return kValue; }); - }; - - const Kind in_kind = kind_of(a->Object()->Type()); - auto desc_of = [&](Kind kind, const core::type::Type* type) { - switch (kind) { - case kPtr: - return StyledText{} - << style::Type("ptr<", obj_view->AddressSpace(), ", ", type->FriendlyName(), - ", ", obj_view->Access(), ">"); - case kRef: - return StyledText{} - << style::Type("ref<", obj_view->AddressSpace(), ", ", type->FriendlyName(), - ", ", obj_view->Access(), ">"); - default: - return NameOf(type); - } - }; - - for (size_t i = 0; i < a->Indices().Length(); i++) { - auto err = [&]() -> diag::Diagnostic& { - return AddError(a, i + Access::kIndicesOperandOffset); - }; - auto note = [&]() -> diag::Diagnostic& { - return AddOperandNote(a, i + Access::kIndicesOperandOffset); - }; - - auto* index = a->Indices()[i]; - if (DAWN_UNLIKELY(!index->Type() || !index->Type()->IsIntegerScalar())) { - err() << "index type " << NameOf(index->Type()) << " must be an integer"; - return; - } - - if (!capabilities_.Contains(Capability::kAllowVectorElementPointer)) { - if (in_kind != kValue && ty->Is()) { - err() << "cannot obtain address of vector element"; - return; - } - } - - if (auto* const_index = index->As()) { - auto* value = const_index->Value(); - if (!value->Type() || value->Type()->IsSignedIntegerScalar()) { - // index is a signed integer scalar. Check that the index isn't negative. - // If the index is unsigned, we can skip this. - auto idx = value->ValueAs(); - if (DAWN_UNLIKELY(idx < 0)) { - err() << "constant index must be positive, got " << idx; - return; - } - } - - auto idx = value->ValueAs(); - auto* el = ty->Element(idx); - if (DAWN_UNLIKELY(!el)) { - // Is index in bounds? - if (auto el_count = ty->Elements().count; el_count != 0 && idx >= el_count) { - err() << "index out of bounds for type " << desc_of(in_kind, ty); - note() << "acceptable range: [0.." << (el_count - 1) << "]"; - return; - } - err() << "type " << desc_of(in_kind, ty) << " cannot be indexed"; - return; - } - ty = el; - } else { - auto* el = ty->Elements().type; - if (DAWN_UNLIKELY(!el)) { - err() << "type " << desc_of(in_kind, ty) << " cannot be dynamically indexed"; - return; - } - ty = el; - } - } - - auto* want = a->Result()->Type(); - auto* want_view = want->As(); - bool ok = true; - if (obj_view) { - // Pointer source always means pointer result. - ok = (want_view != nullptr) && ty == want_view->StoreType(); - if (ok) { - // Also check that the address space and access modes match. - ok = obj_view->Is() == want_view->Is() && - obj_view->AddressSpace() == want_view->AddressSpace() && - obj_view->Access() == want_view->Access(); - } - } else { - // Otherwise, result types should exactly match. - ok = ty == want; - } - if (DAWN_UNLIKELY(!ok)) { - AddError(a) << "result of access chain is type " << desc_of(in_kind, ty) - << " but instruction type is " << NameOf(want); - } -} - -void Validator::CheckBinary(const Binary* b) { - if (!CheckResultsAndOperands(b, Binary::kNumResults, Binary::kNumOperands)) { - return; - } - - if (b->Op() == core::BinaryOp::kLogicalAnd) { - AddError(b) << "logical-and is not valid in the IR"; - return; - } - if (b->Op() == core::BinaryOp::kLogicalOr) { - AddError(b) << "logical-or is not valid in the IR"; - return; - } - - if (b->LHS() && b->RHS()) { - intrinsic::Context context{b->TableData(), type_mgr_, symbols_}; - - auto overload = - core::intrinsic::LookupBinary(context, b->Op(), b->LHS()->Type(), b->RHS()->Type(), - core::EvaluationStage::kRuntime, /* is_compound */ false); - if (overload != Success) { - AddError(b) << overload.Failure(); - return; - } - - if (auto* result = b->Result(0)) { - if (overload->return_type != result->Type()) { - AddError(b) << "result value type " << NameOf(result->Type()) << " does not match " - << style::Instruction(Disassemble().NameOf(b->Op())) << " result type " - << NameOf(overload->return_type); - } - } - } -} - -void Validator::CheckUnary(const Unary* u) { - if (!CheckResultsAndOperands(u, Unary::kNumResults, Unary::kNumOperands)) { - return; - } - - if (u->Val()) { - intrinsic::Context context{u->TableData(), type_mgr_, symbols_}; - - auto overload = core::intrinsic::LookupUnary(context, u->Op(), u->Val()->Type(), - core::EvaluationStage::kRuntime); - if (overload != Success) { - AddError(u) << overload.Failure(); - return; - } - - if (auto* result = u->Result(0)) { - if (overload->return_type != result->Type()) { - AddError(u) << "result value type " << NameOf(result->Type()) << " does not match " - << style::Instruction(Disassemble().NameOf(u->Op())) << " result type " - << NameOf(overload->return_type); - } - } - } -} - -void Validator::CheckIf(const If* if_) { - CheckResults(if_); - CheckOperands(if_, If::kNumOperands); - - if (if_->Condition() && !if_->Condition()->Type()->Is()) { - AddError(if_, If::kConditionOperandOffset) << "condition type must be 'bool'"; - } - - if (if_->False() && if_->False()->Is()) { - AddError(if_) << "if false block must be a block"; - } - if (if_->True() && if_->True()->Is()) { - AddError(if_) << "if true block must be a block"; - } - - tasks_.Push([this] { control_stack_.Pop(); }); - - if (!if_->False()->IsEmpty()) { - QueueBlock(if_->False()); - } - - QueueBlock(if_->True()); - - tasks_.Push([this, if_] { control_stack_.Push(if_); }); -} - -void Validator::CheckLoop(const Loop* l) { - CheckResults(l); - CheckOperands(l, 0); - - if (!l->Initializer()->IsEmpty()) { - if (!l->Initializer()->Terminator() || - !l->Initializer()->Terminator()->Is()) { - AddError(l->Initializer()) << "loop initializer must have a NextIteration terminator"; - } - } - - // Note: Tasks are queued in reverse order of their execution - tasks_.Push([this, l] { - first_continues_.Remove(l); // No need for this any more. Free memory. - control_stack_.Pop(); - }); - if (!l->Initializer()->IsEmpty()) { - tasks_.Push([this] { EndBlock(); }); - } - tasks_.Push([this] { EndBlock(); }); - if (!l->Continuing()->IsEmpty()) { - tasks_.Push([this] { EndBlock(); }); - } - - // ⎡Initializer ⎤ - // ⎢ ⎡Body ⎤⎥ - // ⎣ ⎣ [Continuing ] ⎦⎦ - - if (!l->Continuing()->IsEmpty()) { - tasks_.Push([this, l] { - CheckLoopContinuing(l); - BeginBlock(l->Continuing()); - }); - } - - tasks_.Push([this, l] { - CheckLoopBody(l); - BeginBlock(l->Body()); - }); - if (!l->Initializer()->IsEmpty()) { - tasks_.Push([this, l] { BeginBlock(l->Initializer()); }); - } - tasks_.Push([this, l] { control_stack_.Push(l); }); -} - -void Validator::CheckLoopBody(const Loop* loop) { - // If the body block has parameters, there must be an initializer block. - if (!loop->Body()->Params().IsEmpty()) { - if (!loop->HasInitializer()) { - AddError(loop) << "loop with body block parameters must have an initializer"; - } - } -} - -void Validator::CheckLoopContinuing(const Loop* loop) { - if (!loop->HasContinuing()) { - return; - } - - // Ensure that values used in the loop continuing are not from the loop body, after a - // continue instruction. - if (auto* first_continue = first_continues_.GetOr(loop, nullptr)) { - // Find the instruction in the body block that is or holds the first continue - // instruction. - const Instruction* holds_continue = first_continue; - while (holds_continue && holds_continue->Block() && - holds_continue->Block() != loop->Body()) { - holds_continue = holds_continue->Block()->Parent(); - } - - // Check that all subsequent instruction values are not used in the continuing block. - for (auto* inst = holds_continue; inst; inst = inst->next) { - for (auto* result : inst->Results()) { - result->ForEachUseUnsorted([&](Usage use) { - if (TransitivelyHolds(loop->Continuing(), use.instruction)) { - AddError(use.instruction, use.operand_index) - << NameOf(result) - << " cannot be used in continuing block as it is declared after the " - "first " - << style::Instruction("continue") << " in the loop's body"; - AddDeclarationNote(result); - AddNote(first_continue) - << "loop body's first " << style::Instruction("continue"); - } - }); - } - } - } - - if (!loop->Continuing()->Terminator()->IsAnyOf()) { - AddError(loop->Continuing()) - << "loop continuing terminator can only be next_iteration or break_if"; - } -} - -void Validator::CheckSwitch(const Switch* s) { - CheckResults(s); - CheckOperands(s, Switch::kNumOperands); - - if (s->Condition() && !s->Condition()->Type()->IsIntegerScalar()) { - auto* cond_ty = s->Condition() ? s->Condition()->Type() : nullptr; - AddError(s, Switch::kConditionOperandOffset) - << "condition type " << NameOf(cond_ty) << " must be an integer scalar"; - } - - tasks_.Push([this] { control_stack_.Pop(); }); - - bool found_default = false; - for (auto& cse : s->Cases()) { - if (cse.block->Is()) { - AddError(s) << "case block must be a block"; - } - - if (cse.selectors.IsEmpty()) { - AddError(s) << "case does not have any selectors"; - } - - QueueBlock(cse.block); - for (const auto& sel : cse.selectors) { - if (sel.IsDefault()) { - if (found_default) { - AddError(s) << "multiple default selectors in switch"; - } - found_default = true; - } else if (!sel.val->Type()->IsIntegerScalar()) { - AddError(s) << "case selector type " << NameOf(sel.val->Type()) - << " must be an integer scalar"; - } - } - } - - if (!found_default) { - AddError(s) << "missing default case for switch"; - } - - tasks_.Push([this, s] { control_stack_.Push(s); }); -} - -void Validator::CheckSwizzle(const Swizzle* s) { - if (!CheckResultsAndOperands(s, Swizzle::kNumResults, Swizzle::kNumOperands)) { - return; - } - - auto* src_vec = s->Object()->Type()->As(); - if (!src_vec) { - AddError(s) << "object of swizzle, " << NameOf(s->Object()) << ", is not a vector, " - << NameOf(s->Object()->Type()); - return; - } - - auto indices = s->Indices(); - if (indices.Length() < Swizzle::kMinNumIndices) { - AddError(s) << "expected at least " << Swizzle::kMinNumIndices << " indices"; - return; - } - - if (indices.Length() > Swizzle::kMaxNumIndices) { - AddError(s) << "expected at most " << Swizzle::kMaxNumIndices << " indices"; - return; - } - - auto elem_count = src_vec->Elements().count; - for (auto& idx : indices) { - if (idx > Swizzle::kMaxIndexValue || idx >= elem_count) { - AddError(s) << "invalid index value"; - return; - } - } - - auto* elem_ty = src_vec->Elements().type; - auto* expected_ty = type_mgr_.MatchWidth(elem_ty, indices.Length()); - auto* result_ty = s->Result()->Type(); - if (result_ty != expected_ty) { - AddError(s) << "result type " << NameOf(result_ty) << " does not match expected type, " - << NameOf(expected_ty); - return; - } -} - -void Validator::CheckTerminator(const Terminator* b) { - // All terminators should have zero results - if (!CheckResults(b, 0)) { - return; - } - - // Operands must be alive and in scope if they are not nullptr. - if (!CheckOperands(b)) { - return; - } - - tint::Switch( - b, // - [&](const ir::BreakIf* i) { CheckBreakIf(i); }, // - [&](const ir::Continue* c) { CheckContinue(c); }, // - [&](const ir::Exit* e) { CheckExit(e); }, // - [&](const ir::NextIteration* n) { CheckNextIteration(n); }, // - [&](const ir::Return* ret) { CheckReturn(ret); }, // - [&](const ir::TerminateInvocation*) {}, // - [&](const ir::Unreachable* u) { CheckUnreachable(u); }, // - [&](Default) { AddError(b) << "missing validation"; }); - - if (b->next) { - AddError(b) << "must be the last instruction in the block"; - } -} - -void Validator::CheckBreakIf(const BreakIf* b) { - if (b->Condition() == nullptr) { - AddError(b) << "break_if condition cannot be nullptr"; - return; - } - - if (!b->Condition()->Type() || !b->Condition()->Type()->Is()) { - AddError(b) << "condition must be a 'bool'"; - return; - } - - auto* loop = b->Loop(); - if (loop == nullptr) { - AddError(b) << "has no associated loop"; - return; - } - - if (loop->Continuing() != b->Block()) { - AddError(b) << "must only be called directly from loop continuing"; - } - - auto next_iter_values = b->NextIterValues(); - if (auto* body = loop->Body()) { - CheckOperandsMatchTarget(b, b->ArgsOperandOffset(), next_iter_values.size(), body, - body->Params()); - } - - auto exit_values = b->ExitValues(); - CheckOperandsMatchTarget(b, b->ArgsOperandOffset() + next_iter_values.size(), - exit_values.size(), loop, loop->Results()); -} - -void Validator::CheckContinue(const Continue* c) { - auto* loop = c->Loop(); - if (loop == nullptr) { - AddError(c) << "has no associated loop"; - return; - } - if (!TransitivelyHolds(loop->Body(), c)) { - if (control_stack_.Any(Eq(loop))) { - AddError(c) << "must only be called from loop body"; - } else { - AddError(c) << "called outside of associated loop"; - } - } - - if (auto* cont = loop->Continuing()) { - CheckOperandsMatchTarget(c, Continue::kArgsOperandOffset, c->Args().Length(), cont, - cont->Params()); - } - - first_continues_.Add(loop, c); -} - -void Validator::CheckExit(const Exit* e) { - if (e->ControlInstruction() == nullptr) { - AddError(e) << "has no parent control instruction"; - return; - } - - if (control_stack_.IsEmpty()) { - AddError(e) << "found outside all control instructions"; - return; - } - - auto args = e->Args(); - CheckOperandsMatchTarget(e, e->ArgsOperandOffset(), args.Length(), e->ControlInstruction(), - e->ControlInstruction()->Results()); - - tint::Switch( - e, // - [&](const ir::ExitIf* i) { CheckExitIf(i); }, // - [&](const ir::ExitLoop* l) { CheckExitLoop(l); }, // - [&](const ir::ExitSwitch* s) { CheckExitSwitch(s); }, // - [&](Default) { AddError(e) << "missing validation"; }); -} - -void Validator::CheckNextIteration(const NextIteration* n) { - auto* loop = n->Loop(); - if (loop == nullptr) { - AddError(n) << "has no associated loop"; - return; - } - if (!TransitivelyHolds(loop->Initializer(), n) && !TransitivelyHolds(loop->Continuing(), n)) { - if (control_stack_.Any(Eq(loop))) { - AddError(n) << "must only be called from loop initializer or continuing"; - } else { - AddError(n) << "called outside of associated loop"; - } - } - - if (auto* body = loop->Body()) { - CheckOperandsMatchTarget(n, NextIteration::kArgsOperandOffset, n->Args().Length(), body, - body->Params()); - } -} - -void Validator::CheckExitIf(const ExitIf* e) { - if (control_stack_.Back() != e->If()) { - AddError(e) << "if target jumps over other control instructions"; - AddNote(control_stack_.Back()) << "first control instruction jumped"; - } -} - -void Validator::CheckReturn(const Return* ret) { - if (!CheckOperands(ret, Return::kMinOperands, Return::kMaxOperands)) { - return; - } - - auto* func = ret->Func(); - if (func == nullptr) { - // Func() returning nullptr after CheckResultsAndOperandRange is due to the first - // operand being not a function - AddError(ret) << "expected function for first operand"; - return; - } - - if (func != ContainingFunction(ret)) { - AddError(ret) << "function operand does not match containing function"; - return; - } - - if (func->ReturnType()->Is()) { - if (ret->HasValue()) { - AddError(ret) << "unexpected return value"; - } - } else { - if (!ret->Value()) { - AddError(ret) << "expected return value"; - } else if (ret->Value()->Type() != func->ReturnType()) { - AddError(ret) << "return value type " << NameOf(ret->Value()->Type()) - << " does not match function return type " << NameOf(func->ReturnType()); - } - } -} - -void Validator::CheckUnreachable(const Unreachable* u) { - CheckResultsAndOperands(u, Unreachable::kNumResults, Unreachable::kNumOperands); -} - -void Validator::CheckControlsAllowingIf(const Exit* exit, const Instruction* control) { - bool found = false; - for (auto ctrl : tint::Reverse(control_stack_)) { - if (ctrl == control) { - found = true; - break; - } - // A exit switch can step over if instructions, but no others. - if (!ctrl->Is()) { - AddError(exit) << control->FriendlyName() - << " target jumps over other control instructions"; - AddNote(ctrl) << "first control instruction jumped"; - return; - } - } - if (!found) { - AddError(exit) << control->FriendlyName() << " not found in parent control instructions"; - } -} - -void Validator::CheckExitSwitch(const ExitSwitch* s) { - CheckControlsAllowingIf(s, s->ControlInstruction()); -} - -void Validator::CheckExitLoop(const ExitLoop* l) { - CheckControlsAllowingIf(l, l->ControlInstruction()); - - const Instruction* inst = l; - const Loop* control = l->Loop(); - while (inst) { - // Found parent loop - if (inst->Block()->Parent() == control) { - if (inst->Block() == control->Continuing()) { - AddError(l) << "loop exit jumps out of continuing block"; - if (control->Continuing() != l->Block()) { - AddNote(control->Continuing()) << "in continuing block"; - } - } else if (inst->Block() == control->Initializer()) { - AddError(l) << "loop exit not permitted in loop initializer"; - if (control->Initializer() != l->Block()) { - AddNote(control->Initializer()) << "in initializer block"; - } - } - break; - } - inst = inst->Block()->Parent(); - } -} - -bool Validator::CanLoad(const core::type::Type* ty) { - return tint::Switch( - ty, // - [&](const core::type::Array* arr) { - if (arr->Count()->Is()) { - return false; - } - return CanLoad(arr->Elements().type); - }, - [&](const core::type::Struct* str) { - for (auto* member : str->Members()) { - if (member->Type()->Is() && - capabilities_.Contains(Capability::kMslAllowEntryPointInterface)) { - continue; - } - if (!CanLoad(member->Type())) { - return false; - } - } - return true; - }, - [&](Default) { return ty->IsConstructible() || ty->IsHandle(); }); -} - -void Validator::CheckLoad(const Load* l) { - if (!CheckResultsAndOperands(l, Load::kNumResults, Load::kNumOperands)) { - return; - } - - if (auto* from = l->From()) { - auto* mv = from->Type()->As(); - if (!mv) { - AddError(l, Load::kFromOperandOffset) - << "load source operand " << NameOf(from->Type()) << " is not a memory view"; - return; - } - - if (mv->Access() != core::Access::kRead && mv->Access() != core::Access::kReadWrite) { - AddError(l, Load::kFromOperandOffset) - << "load source operand has a non-readable access type, " - << style::Literal(ToString(mv->Access())); - return; - } - - if (l->Result()->Type() != mv->StoreType()) { - AddError(l, Load::kFromOperandOffset) - << "result type " << NameOf(l->Result()->Type()) - << " does not match source store type " << NameOf(mv->StoreType()); - } - - if (!CanLoad(mv->StoreType())) { - AddError(l, Load::kFromOperandOffset) - << "type " << NameOf(mv->StoreType()) << " cannot be loaded"; - return; - } - } -} - -void Validator::CheckStore(const Store* s) { - if (!CheckResultsAndOperands(s, Store::kNumResults, Store::kNumOperands)) { - return; - } - - if (auto* from = s->From()) { - if (auto* to = s->To()) { - auto* mv = As(to->Type()); - if (!mv) { - AddError(s, Store::kToOperandOffset) - << "store target operand " << NameOf(to->Type()) << " is not a memory view"; - return; - } - - if (mv->Access() != core::Access::kWrite && mv->Access() != core::Access::kReadWrite) { - AddError(s, Store::kToOperandOffset) - << "store target operand has a non-writeable access type, " - << style::Literal(ToString(mv->Access())); - return; - } - - auto* value_type = from->Type(); - auto* store_type = mv->StoreType(); - if (value_type != store_type) { - AddError(s, Store::kFromOperandOffset) - << "value type " << NameOf(value_type) << " does not match store type " - << NameOf(store_type); - return; - } - - if (!store_type->IsConstructible()) { - AddError(s) << "store type " << NameOf(store_type) << " is not constructible"; - return; - } - } - } -} - -void Validator::CheckLoadVectorElement(const LoadVectorElement* l) { - if (!CheckResultsAndOperands(l, LoadVectorElement::kNumResults, - LoadVectorElement::kNumOperands)) { - return; - } - - if (auto* res = l->Result(0)) { - auto* el_ty = GetVectorPtrElementType(l, LoadVectorElement::kFromOperandOffset); - if (!el_ty) { - return; - } - if (res->Type() != el_ty) { - AddResultError(l, 0) << "result type " << NameOf(res->Type()) - << " does not match vector pointer element type " << NameOf(el_ty); - return; - } - } - - if (!l->Index()->Type()->IsIntegerScalar()) { - AddError(l, LoadVectorElement::kIndexOperandOffset) - << "load vector element index must be an integer scalar"; - } - if (auto* c = l->Index()->As()) { - auto val = c->Value()->ValueAs(); - - auto* vec_ty = l->From()->Type()->UnwrapPtrOrRef()->As(); - TINT_ASSERT(vec_ty); - - if (val >= vec_ty->Width()) { - AddError(l, LoadVectorElement::kIndexOperandOffset) - << "load vector element index must be in range [0, " << (vec_ty->Width() - 1) - << "]"; - } - } -} - -void Validator::CheckStoreVectorElement(const StoreVectorElement* s) { - if (!CheckResultsAndOperands(s, StoreVectorElement::kNumResults, - StoreVectorElement::kNumOperands)) { - return; - } - - if (auto* value = s->Value()) { - auto* el_ty = GetVectorPtrElementType(s, StoreVectorElement::kToOperandOffset); - if (!el_ty) { - return; - } - if (value->Type() != el_ty) { - AddError(s, StoreVectorElement::kValueOperandOffset) - << "value type " << NameOf(value->Type()) - << " does not match vector pointer element type " << NameOf(el_ty); - return; - } - - // The `GetVectorPtrElementType` has already validated that the pointer exists. - auto* mv = s->To()->Type()->As(); - if (mv->Access() != core::Access::kWrite && mv->Access() != core::Access::kReadWrite) { - AddError(s, StoreVectorElement::kToOperandOffset) - << "store_vector_element target operand has a non-writeable access type, " - << style::Literal(ToString(mv->Access())); - return; - } - } - - if (!s->Index()->Type()->IsIntegerScalar()) { - AddError(s, StoreVectorElement::kIndexOperandOffset) - << "store vector element index must be an integer scalar"; - } - if (auto* c = s->Index()->As()) { - auto val = c->Value()->ValueAs(); - - auto* vec_ty = s->To()->Type()->UnwrapPtrOrRef()->As(); - TINT_ASSERT(vec_ty); - - if (val >= vec_ty->Width()) { - AddError(s, StoreVectorElement::kIndexOperandOffset) - << "store vector element index must be in range [0, " << (vec_ty->Width() - 1) - << "]"; - } - } -} - -void Validator::CheckPhony(const Phony* p) { - if (!capabilities_.Contains(Capability::kAllowPhonyInstructions)) { - AddError(p) << "missing capability 'kAllowPhonyInstructions'"; - return; - } - - if (!CheckResultsAndOperands(p, Phony::kNumResults, Phony::kNumOperands)) { - return; - } -} - -void Validator::CheckOperandsMatchTarget(const Instruction* source_inst, - size_t source_operand_offset, - size_t source_operand_count, - const CastableBase* target, - VectorRef target_values) { - if (source_operand_count != target_values.Length()) { - auto values = [&](size_t n) { return n == 1 ? " value" : " values"; }; - AddError(source_inst) << "provides " << source_operand_count << values(source_operand_count) - << " but " << NameOf(target) << " expects " << target_values.Length() - << values(target_values.Length()); - AddDeclarationNote(target); - } - size_t count = std::min(source_operand_count, target_values.Length()); - for (size_t i = 0; i < count; i++) { - auto* source_value = source_inst->Operand(source_operand_offset + i); - auto* target_value = target_values[i]; - if (!source_value || !target_value) { - continue; // Caller should be checking operands are not null - } - auto* source_type = source_value->Type(); - auto* target_type = target_value->Type(); - if (source_type != target_type) { - AddError(source_inst, source_operand_offset + i) - << "operand with type " << NameOf(source_type) << " does not match " - << NameOf(target) << " target type " << NameOf(target_type); - AddDeclarationNote(target_value); - } - } -} - -const core::type::Type* Validator::GetVectorPtrElementType(const Instruction* inst, size_t idx) { - auto* operand = inst->Operands()[idx]; - if (DAWN_UNLIKELY(!operand)) { - AddError(inst, idx) << "missing element operand"; - return nullptr; - } - - auto* type = operand->Type(); - if (DAWN_UNLIKELY(!type)) { - AddError(inst, idx) << "missing operand type"; - return nullptr; - } - - auto* memory_view_ty = type->As(); - if (DAWN_LIKELY(memory_view_ty)) { - auto* vec_ty = memory_view_ty->StoreType()->As(); - if (DAWN_LIKELY(vec_ty)) { - return vec_ty->Type(); - } - } - - AddError(inst, idx) << "operand " << NameOf(type) << " must be a pointer to a vector"; - return nullptr; -} - } // namespace -Result Validate(const Module& mod, - Capabilities capabilities, - [[maybe_unused]] const char* msg, - [[maybe_unused]] std::string_view timing) { - DumpIRIfEnabled(mod, msg, timing); +/// TODO(crbug.com/512904070): Remove this when transition to properties is complete. +Result Validate(const Module& mod, Capabilities capabilities, std::string_view msg) { + DumpIRIfEnabled(mod, msg); Validator v(mod, capabilities); - TINT_CHECK_RESULT(v.Run()); - return Success; + return v.Run(); } -Result ValidateBefore(const Module& mod, Capabilities capabilities, const char* msg) { - return Validate(mod, capabilities, msg, "before"); +Result Validate(const Module& mod, std::string_view msg) { + DumpIRIfEnabled(mod, msg); + Validator v(mod); + return v.Run(); } -Result ValidateAfter(const Module& mod, Capabilities capabilities, const char* msg) { - return Validate(mod, capabilities, msg, "after"); -} +/// TODO(crbug.com/512904070): Remove this when transition to properties is complete. +void AssertValid(const Module& mod, + [[maybe_unused]] Capabilities capabilities, + std::string_view msg) { + DumpIRIfEnabled(mod, msg); -Result ValidateIfNeeded([[maybe_unused]] const Module& mod, - [[maybe_unused]] Capabilities capabilities, - [[maybe_unused]] const char* msg, - [[maybe_unused]] std::string_view timing) { - DumpIRIfEnabled(mod, msg, timing); -#if TINT_ENABLE_IR_VALIDATION - Validator v(mod, capabilities); - TINT_CHECK_RESULT(v.Run()); +#if TINT_ENABLE_IR_VALIDATION_ASSERTS + if (mod.enable_validation_asserts) { + Validator v(mod, capabilities); + auto result = v.Run(); + if (result != Success) { + TINT_ICE() << "\n=========================================================" + << "\n== IR validation failed " << msg << ":" + << "\n=========================================================\n" + << result.Failure().reason; + } + } #endif - return Success; } -Result ValidateBeforeIfNeeded(const Module& mod, - Capabilities capabilities, - const char* msg) { - return ValidateIfNeeded(mod, capabilities, msg, "before"); +void AssertValid(const Module& mod, std::string_view msg) { + DumpIRIfEnabled(mod, msg); + +#if TINT_ENABLE_IR_VALIDATION_ASSERTS + if (mod.enable_validation_asserts) { + Validator v(mod); + auto result = v.Run(); + if (result != Success) { + TINT_ICE() << "\n=========================================================" + << "\n== IR validation failed " << msg << ":" + << "\n=========================================================\n" + << result.Failure().reason; + } + } +#endif } -Result ValidateAfterIfNeeded(const Module& mod, - Capabilities capabilities, - const char* msg) { - return ValidateIfNeeded(mod, capabilities, msg, "after"); +void AssertNoUnsupportedProperties(const Module& mod, Properties unsupported_properties) { + auto check = mod.properties & unsupported_properties; + TINT_IR_ASSERT(mod, check.Empty()) << "unsupported property '" << *check.begin() << "'"; } } // namespace tint::core::ir - -namespace std { - -template <> -struct hash { - size_t operator()(const tint::core::ir::ValidatedType& v) const { return Hash(v.ty, v.caps); } -}; - -template <> -struct equal_to { - bool operator()(const tint::core::ir::ValidatedType& a, - const tint::core::ir::ValidatedType& b) const { - return a.ty->Equals(*(b.ty)) && a.caps == b.caps; - } -}; - -} // namespace std diff --git a/3rdparty/dawn/src/tint/lang/core/ir/validator.h b/3rdparty/dawn/src/tint/lang/core/ir/validator.h index c9ea30bea..116a00044 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/validator.h +++ b/3rdparty/dawn/src/tint/lang/core/ir/validator.h @@ -28,136 +28,41 @@ #ifndef SRC_TINT_LANG_CORE_IR_VALIDATOR_H_ #define SRC_TINT_LANG_CORE_IR_VALIDATOR_H_ -#include - -#include "src/tint/utils/containers/enum_set.h" +#include "src/tint/lang/core/ir/capabilities.h" +#include "src/tint/lang/core/ir/module.h" #include "src/tint/utils/result.h" -// Forward declarations namespace tint::core::ir { -class Module; -} // namespace tint::core::ir - -namespace tint::core::ir { - -/// Enumerator of optional IR capabilities. -enum class Capability : uint8_t { - /// Allows 8-bit integer types. - kAllow8BitIntegers, - /// Allows 16-bit integer types. - kAllow16BitIntegers, - /// Allows 64-bit integer types. - kAllow64BitIntegers, - /// Allows ClipDistances on f32 and vecN parameters - kAllowClipDistancesOnF32ScalarAndVector, - /// Allows handle vars to not have binding points - kAllowHandleVarsWithoutBindings, - /// Allows module scoped lets - kAllowModuleScopeLets, - /// Allows multiple entry points in the module. - kAllowMultipleEntryPoints, - /// Allow overrides - kAllowOverrides, - /// Allows ref types - kAllowRefTypes, - /// Allows access instructions to create pointers to vector elements. - kAllowVectorElementPointer, - /// Allows phony assignment instructions to be used. - kAllowPhonyInstructions, - /// Allows lets to have any type, used by MSL backend for module scoped vars - kAllowAnyLetType, - /// Allows input_attachment_index to be associated with any type, used by - /// SPIRV backend for spirv.image. - kAllowAnyInputAttachmentIndexType, - /// Allows binding points to be non-unique. Used after BindingRemapper is - /// invoked by MSL & GLSL backends. - kAllowDuplicateBindings, - /// Allows module scope `var`s to exist without an IO annotation - kAllowUnannotatedModuleIOVariables, - /// Allows non-core types in the IR module - kAllowNonCoreTypes, - /// Allows matrix annotations on structure members - kAllowStructMatrixDecorations, - /// Allows @location on structs, matrices, and arrays that have numeric elements - kAllowLocationForNumericElements, - /// Allows a pointer to a handle type - kAllowPointerToHandle, - /// Allows ShaderIO specific features, like blend_src on non-struct members. - /// These are not separate capabilities, because they are enabled/disabled in lockstep with each - /// other. - /// TODO(448417342): Validate in/out address space usage based on this capability - kLoosenValidationForShaderIO, - /// Allows the PointSize builtin to be used. - kAllowPointSizeBuiltin, - /// Allows MSL specific entry point variance. - /// Specifically pointers and handle address space variables inside structures, private address - /// space variables in function scopes, workgroup address space pointers as entry point inputs, - /// binding point on non-module scope variables in entry point interface. - kMslAllowEntryPointInterface, -}; - -/// Capabilities is a set of Capability -using Capabilities = EnumSet; /// Validates the module @p ir is correctly formed /// @param mod the module to validate /// @param capabilities the optional capabilities that are allowed /// @param msg the msg to accompany the output -/// @param timing when the validation is run. /// @returns success or failure Result Validate(const Module& mod, - Capabilities capabilities = {}, - const char* msg = "", - std::string_view timing = ""); + Capabilities capabilities, + std::string_view msg = ""); -/// Validates the module @p ir is correctly formed before an operation +/// Validates the module @p ir is correctly formed /// @param mod the module to validate -/// @param capabilities the optional capabilities that are allowed -/// @param msg the msg to accompany the output to indicate the operation +/// @param msg the msg to accompany the output /// @returns success or failure -Result ValidateBefore(const Module& mod, - Capabilities capabilities = {}, - const char* msg = ""); +Result Validate(const Module& mod, std::string_view msg = ""); -/// Validates the module @p ir is correctly formed after an operation -/// @param mod the module to validate +/// Validates the module @p ir is correctly formed, iff required by the build configuration. +/// @param mod the module to transformG /// @param capabilities the optional capabilities that are allowed -/// @param msg the msg to accompany the output to indicate the step -/// @returns success or failure -Result ValidateAfter(const Module& mod, - Capabilities capabilities = {}, - const char* msg = ""); +/// @param msg the msg to accompany the output +void AssertValid(const Module& mod, Capabilities capabilities, std::string_view msg = ""); /// Validates the module @p ir is correctly formed, iff required by the build configuration. /// @param mod the module to transform -/// @param capabilities the optional capabilities that are allowed /// @param msg the msg to accompany the output -/// @param timing when the validation is run. -/// @returns success or failure -Result ValidateIfNeeded(const Module& mod, - Capabilities capabilities = {}, - const char* msg = "", - std::string_view timing = ""); +void AssertValid(const Module& mod, std::string_view msg = ""); -/// Validates the module @p ir is correctly formed before an operation, iff required by the build -/// configuration. -/// @param mod the module to validate -/// @param capabilities the optional capabilities that are allowed -/// @param msg the msg to accompany the output to indicate the operation -/// @returns success or failure -Result ValidateBeforeIfNeeded(const Module& mod, - Capabilities capabilities = {}, - const char* msg = ""); - -/// Validates the module @p ir is correctly formed after an operation, iff required by the build -/// configuration. -/// @param mod the module to validate -/// @param capabilities the optional capabilities that are allowed -/// @param msg the msg to accompany the output to indicate the operation -/// @returns success or failure -Result ValidateAfterIfNeeded(const Module& mod, - Capabilities capabilities = {}, - const char* msg = ""); +/// Check if @p mod contains any of the properties in @p unsupported_properties. +/// Raises a Tint ICE with the name of first unsupported property that was found. +void AssertNoUnsupportedProperties(const Module& mod, Properties unsupported_properties); } // namespace tint::core::ir diff --git a/3rdparty/dawn/src/tint/lang/core/type/array.cc b/3rdparty/dawn/src/tint/lang/core/type/array.cc index 6299d0a34..8c74c5265 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/array.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/array.cc @@ -58,7 +58,9 @@ core::type::Flags FlagsFrom(const Type* element, const ArrayCount* count) { flags.Add(Flag::kFixedFootprint); } } - if (element->IsHostShareable()) { + // Host-shareable if the element is host-shareable AND the count is not override sized. + if (element->IsHostShareable() && + (count->Is() || count->Is())) { flags.Add(Flag::kHostShareable); } return flags; diff --git a/3rdparty/dawn/src/tint/lang/core/type/array_count.h b/3rdparty/dawn/src/tint/lang/core/type/array_count.h index 8a8d4ee4a..613e5ebfa 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/array_count.h +++ b/3rdparty/dawn/src/tint/lang/core/type/array_count.h @@ -80,7 +80,7 @@ class ConstantArrayCount final : public Castable ConstantArrayCount* Clone(CloneContext& ctx) const override; /// The array count constant-expression value. - uint32_t value; + uint32_t value = 0; }; /// The variant of an ArrayCount when the array is runtime-sized. diff --git a/3rdparty/dawn/src/tint/lang/core/type/binding_array.cc b/3rdparty/dawn/src/tint/lang/core/type/binding_array.cc index a8fa53764..b991f1d32 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/binding_array.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/binding_array.cc @@ -65,11 +65,18 @@ std::string BindingArray::FriendlyName() const { TypeAndCount BindingArray::Elements([[maybe_unused]] const Type*, [[maybe_unused]] uint32_t count_if_invalid) const { - return {element_, count_->As()->value}; + uint32_t n = count_if_invalid; + if (auto* const_count = count_->As()) { + n = const_count->value; + } + return {element_, n}; } const Type* BindingArray::Element(uint32_t index) const { - return index < count_->As()->value ? element_ : nullptr; + if (auto* count = count_->As()) { + return index < count->value ? element_ : nullptr; + } + return element_; } BindingArray* BindingArray::Clone(CloneContext& ctx) const { diff --git a/3rdparty/dawn/src/tint/lang/core/type/buffer.cc b/3rdparty/dawn/src/tint/lang/core/type/buffer.cc index 44b972b3a..009f376ba 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/buffer.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/buffer.cc @@ -33,8 +33,12 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::type::Buffer); namespace tint::core::type { +const core::type::Flags sizedFlags{Flag::kHostShareable, Flag::kFixedFootprint}; +const core::type::Flags unsizedFlags{Flag::kHostShareable}; + Buffer::Buffer(const ArrayCount* size) - : Base(Hash(tint::TypeCode::Of().bits, size), core::type::Flags{Flag::kHostShareable}), + : Base(Hash(tint::TypeCode::Of().bits, size), + (size->Is() ? unsizedFlags : sizedFlags)), count_(size) {} Buffer::~Buffer() = default; diff --git a/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.cc b/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.cc index 47664f0ec..a5a72c25b 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.cc @@ -195,4 +195,21 @@ Struct* CreateAtomicCompareExchangeResult(Manager& types, SymbolTable& symbols, TINT_ICE_ON_NO_MATCH); } +Struct* CreateAddCarryResult(Manager& types, SymbolTable& symbols, const Type* ty) { + std::string name = "add_carry_result_"; + if (auto* vec_ty = ty->As()) { + name += "vec" + std::to_string(vec_ty->Width()) + "_"; + } + name += ty->DeepestElement()->FriendlyName(); + + auto symbol = symbols.Register(name); + if (auto* existing = types.Find(symbol, /* is_wgsl_internal */ true)) { + return existing; + } + return types.WgslInternalStruct(symbol, { + {symbols.Register("result"), ty}, + {symbols.Register("carry"), ty}, + }); +} + } // namespace tint::core::type diff --git a/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.h b/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.h index 9f8ec5ec5..e5b8c8587 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.h +++ b/3rdparty/dawn/src/tint/lang/core/type/builtin_structs.h @@ -58,6 +58,12 @@ Struct* CreateFrexpResult(Manager& types, SymbolTable& symbols, const Type* frac /// @returns the builtin struct type for a atomic_compare_exchange() builtin call. Struct* CreateAtomicCompareExchangeResult(Manager& types, SymbolTable& symbols, const Type* ty); +/// @param types the type manager +/// @param symbols the symbol table +/// @param ty the type of the struct members. +/// @returns the builtin struct type for a spirv.add_carry builtin call. +Struct* CreateAddCarryResult(Manager& types, SymbolTable& symbols, const Type* ty); + } // namespace tint::core::type #endif // SRC_TINT_LANG_CORE_TYPE_BUILTIN_STRUCTS_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/type/manager.cc b/3rdparty/dawn/src/tint/lang/core/type/manager.cc index 9b6b6f3d9..13a86e6d0 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/manager.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/manager.cc @@ -262,12 +262,6 @@ const core::type::SampledTexture* Manager::sampled_texture(TextureDimension dim, return Get(dim, type); } -const core::type::SampledTexture* Manager::sampled_texture(TextureDimension dim, - const core::type::Type* type, - TextureFilterable filterable) { - return Get(dim, type, filterable); -} - const core::type::MultisampledTexture* Manager::multisampled_texture(TextureDimension dim, const core::type::Type* type) { return Get(dim, type); diff --git a/3rdparty/dawn/src/tint/lang/core/type/manager.h b/3rdparty/dawn/src/tint/lang/core/type/manager.h index f4023d8d0..145630620 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/manager.h +++ b/3rdparty/dawn/src/tint/lang/core/type/manager.h @@ -193,9 +193,8 @@ class Manager final { /// @param args the arguments used to create the temporary used for the search. /// @return a pointer to an instance of `T` with the provided arguments, or nullptr if the item /// was not found. - template >, - typename... ARGS> + template + requires(tint::traits::IsTypeOrDerived) auto* Find(ARGS&&... args) const { return types_.Find(std::forward(args)...); } @@ -320,14 +319,6 @@ class Manager final { const core::type::SampledTexture* sampled_texture(TextureDimension dim, const core::type::Type* type); - /// @param dim the dimensionality of the texture - /// @param type the data type of the sampled texture - /// @param filterable the filterablity - /// @returns a sampled texture type with the provided params - const core::type::SampledTexture* sampled_texture(TextureDimension dim, - const core::type::Type* type, - TextureFilterable filterable); - /// @param dim the dimensionality of the texture /// @param type the data type of the sampled texture /// @returns a multisampled texture type with the provided params @@ -678,12 +669,6 @@ class Manager final { return Get(core::type::SamplerKind::kSampler); } - /// @param filtering the sampler filtering parameter - /// @returns the sampler type - const core::type::Sampler* sampler(SamplerFiltering filtering) { - return Get(core::type::SamplerKind::kSampler, filtering); - } - /// @returns the comparison sampler type const core::type::Sampler* comparison_sampler() { return Get(core::type::SamplerKind::kComparisonSampler); diff --git a/3rdparty/dawn/src/tint/lang/core/type/resource_type.cc b/3rdparty/dawn/src/tint/lang/core/type/resource_type.cc index cf55ba72f..abdf1eaa3 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/resource_type.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/resource_type.cc @@ -42,61 +42,49 @@ namespace tint::core::type { const core::type::Type* ResourceTypeToType(core::type::Manager& ty, ResourceType type) { switch (type) { case ResourceType::kTexture1d_f32_filterable: - return ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32(), - core::TextureFilterable::kFilterable); case ResourceType::kTexture1d_f32_unfilterable: - return ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32(), - core::TextureFilterable::kUnfilterable); + case ResourceType::kTexture1d_f32_unknown_filterable: + return ty.sampled_texture(core::type::TextureDimension::k1d, ty.f32()); case ResourceType::kTexture1d_i32: return ty.sampled_texture(core::type::TextureDimension::k1d, ty.i32()); case ResourceType::kTexture1d_u32: return ty.sampled_texture(core::type::TextureDimension::k1d, ty.u32()); case ResourceType::kTexture2d_f32_filterable: - return ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32(), - core::TextureFilterable::kFilterable); case ResourceType::kTexture2d_f32_unfilterable: - return ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32(), - core::TextureFilterable::kUnfilterable); + case ResourceType::kTexture2d_f32_unknown_filterable: + return ty.sampled_texture(core::type::TextureDimension::k2d, ty.f32()); case ResourceType::kTexture2d_i32: return ty.sampled_texture(core::type::TextureDimension::k2d, ty.i32()); case ResourceType::kTexture2d_u32: return ty.sampled_texture(core::type::TextureDimension::k2d, ty.u32()); case ResourceType::kTexture2dArray_f32_filterable: - return ty.sampled_texture(core::type::TextureDimension::k2dArray, ty.f32(), - core::TextureFilterable::kFilterable); case ResourceType::kTexture2dArray_f32_unfilterable: - return ty.sampled_texture(core::type::TextureDimension::k2dArray, ty.f32(), - core::TextureFilterable::kUnfilterable); + case ResourceType::kTexture2dArray_f32_unknown_filterable: + return ty.sampled_texture(core::type::TextureDimension::k2dArray, ty.f32()); case ResourceType::kTexture2dArray_i32: return ty.sampled_texture(core::type::TextureDimension::k2dArray, ty.i32()); case ResourceType::kTexture2dArray_u32: return ty.sampled_texture(core::type::TextureDimension::k2dArray, ty.u32()); case ResourceType::kTexture3d_f32_filterable: - return ty.sampled_texture(core::type::TextureDimension::k3d, ty.f32(), - core::TextureFilterable::kFilterable); case ResourceType::kTexture3d_f32_unfilterable: - return ty.sampled_texture(core::type::TextureDimension::k3d, ty.f32(), - core::TextureFilterable::kUnfilterable); + case ResourceType::kTexture3d_f32_unknown_filterable: + return ty.sampled_texture(core::type::TextureDimension::k3d, ty.f32()); case ResourceType::kTexture3d_i32: return ty.sampled_texture(core::type::TextureDimension::k3d, ty.i32()); case ResourceType::kTexture3d_u32: return ty.sampled_texture(core::type::TextureDimension::k3d, ty.u32()); case ResourceType::kTextureCube_f32_filterable: - return ty.sampled_texture(core::type::TextureDimension::kCube, ty.f32(), - core::TextureFilterable::kFilterable); case ResourceType::kTextureCube_f32_unfilterable: - return ty.sampled_texture(core::type::TextureDimension::kCube, ty.f32(), - core::TextureFilterable::kUnfilterable); + case ResourceType::kTextureCube_f32_unknown_filterable: + return ty.sampled_texture(core::type::TextureDimension::kCube, ty.f32()); case ResourceType::kTextureCube_i32: return ty.sampled_texture(core::type::TextureDimension::kCube, ty.i32()); case ResourceType::kTextureCube_u32: return ty.sampled_texture(core::type::TextureDimension::kCube, ty.u32()); case ResourceType::kTextureCubeArray_f32_filterable: - return ty.sampled_texture(core::type::TextureDimension::kCubeArray, ty.f32(), - core::TextureFilterable::kFilterable); case ResourceType::kTextureCubeArray_f32_unfilterable: - return ty.sampled_texture(core::type::TextureDimension::kCubeArray, ty.f32(), - core::TextureFilterable::kUnfilterable); + case ResourceType::kTextureCubeArray_f32_unknown_filterable: + return ty.sampled_texture(core::type::TextureDimension::kCubeArray, ty.f32()); case ResourceType::kTextureCubeArray_i32: return ty.sampled_texture(core::type::TextureDimension::kCubeArray, ty.i32()); case ResourceType::kTextureCubeArray_u32: @@ -120,15 +108,114 @@ const core::type::Type* ResourceTypeToType(core::type::Manager& ty, ResourceType case ResourceType::kTextureDepthMultisampled2d: return ty.depth_multisampled_texture(core::type::TextureDimension::k2d); + case ResourceType::kSampler: case ResourceType::kSampler_filtering: - return ty.sampler(core::SamplerFiltering::kFiltering); case ResourceType::kSampler_non_filtering: - return ty.sampler(core::SamplerFiltering::kNonFiltering); + return ty.sampler(); case ResourceType::kSampler_comparison: return ty.comparison_sampler(); - default: - TINT_UNREACHABLE(); + case ResourceType::kEmpty: + break; } + TINT_UNREACHABLE(); +} + +ResourceType DefaultResourceTypeFor(const core::type::Type* in_type) { + return tint::Switch( + in_type, + [&](const core::type::SampledTexture* sa) { + switch (sa->Dim()) { + case core::type::TextureDimension::k1d: + return tint::Switch( + sa->Type(), + [&](const core::type::F32*) { + return ResourceType::kTexture1d_f32_filterable; + }, + [&](const core::type::I32*) { return ResourceType::kTexture1d_i32; }, + [&](const core::type::U32*) { return ResourceType::kTexture1d_u32; }, + TINT_ICE_ON_NO_MATCH); + case core::type::TextureDimension::k2d: + return tint::Switch( + sa->Type(), + [&](const core::type::F32*) { + return ResourceType::kTexture2d_f32_filterable; + }, + [&](const core::type::I32*) { return ResourceType::kTexture2d_i32; }, + [&](const core::type::U32*) { return ResourceType::kTexture2d_u32; }, + TINT_ICE_ON_NO_MATCH); + case core::type::TextureDimension::k2dArray: + return tint::Switch( + sa->Type(), + [&](const core::type::F32*) { + return ResourceType::kTexture2dArray_f32_filterable; + }, + [&](const core::type::I32*) { return ResourceType::kTexture2dArray_i32; }, + [&](const core::type::U32*) { return ResourceType::kTexture2dArray_u32; }, + TINT_ICE_ON_NO_MATCH); + case core::type::TextureDimension::k3d: + return tint::Switch( + sa->Type(), + [&](const core::type::F32*) { + return ResourceType::kTexture3d_f32_filterable; + }, + [&](const core::type::I32*) { return ResourceType::kTexture3d_i32; }, + [&](const core::type::U32*) { return ResourceType::kTexture3d_u32; }, + TINT_ICE_ON_NO_MATCH); + case core::type::TextureDimension::kCube: + return tint::Switch( + sa->Type(), + [&](const core::type::F32*) { + return ResourceType::kTextureCube_f32_filterable; + }, + [&](const core::type::I32*) { return ResourceType::kTextureCube_i32; }, + [&](const core::type::U32*) { return ResourceType::kTextureCube_u32; }, + TINT_ICE_ON_NO_MATCH); + case core::type::TextureDimension::kCubeArray: + return tint::Switch( + sa->Type(), + [&](const core::type::F32*) { + return ResourceType::kTextureCubeArray_f32_filterable; + }, + [&](const core::type::I32*) { return ResourceType::kTextureCubeArray_i32; }, + [&](const core::type::U32*) { return ResourceType::kTextureCubeArray_u32; }, + TINT_ICE_ON_NO_MATCH); + case core::type::TextureDimension::kNone: + TINT_UNREACHABLE(); + } + TINT_UNREACHABLE(); + }, + [&](const core::type::MultisampledTexture* ms) { + return tint::Switch( + ms->Type(), + [&](const core::type::F32*) { return ResourceType::kTextureMultisampled2d_f32; }, + [&](const core::type::I32*) { return ResourceType::kTextureMultisampled2d_i32; }, + [&](const core::type::U32*) { return ResourceType::kTextureMultisampled2d_u32; }, + TINT_ICE_ON_NO_MATCH); + }, + [&](const core::type::DepthMultisampledTexture*) { + return ResourceType::kTextureDepthMultisampled2d; + }, + [&](const core::type::DepthTexture* de) { + switch (de->Dim()) { + case core::type::TextureDimension::k2d: + return ResourceType::kTextureDepth2d; + case core::type::TextureDimension::k2dArray: + return ResourceType::kTextureDepth2dArray; + case core::type::TextureDimension::kCube: + return ResourceType::kTextureDepthCube; + case core::type::TextureDimension::kCubeArray: + return ResourceType::kTextureDepthCubeArray; + default: + TINT_UNREACHABLE(); + } + }, + [&](const core::type::Sampler* s) { + if (s->IsComparison()) { + return ResourceType::kSampler_comparison; + } + return ResourceType::kSampler_non_filtering; + }, + TINT_ICE_ON_NO_MATCH); } ResourceType TypeToResourceType(const core::type::Type* in_type) { @@ -140,14 +227,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return tint::Switch( sa->Type(), [&](const core::type::F32*) { - switch (sa->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceType::kTexture1d_f32_filterable; - case core::TextureFilterable::kUnfilterable: - return ResourceType::kTexture1d_f32_unfilterable; - case core::TextureFilterable::kUndefined: - TINT_UNREACHABLE(); - } + return ResourceType::kTexture1d_f32_unknown_filterable; }, [&](const core::type::I32*) { return ResourceType::kTexture1d_i32; }, [&](const core::type::U32*) { return ResourceType::kTexture1d_u32; }, @@ -156,14 +236,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return tint::Switch( sa->Type(), [&](const core::type::F32*) { - switch (sa->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceType::kTexture2d_f32_filterable; - case core::TextureFilterable::kUnfilterable: - return ResourceType::kTexture2d_f32_unfilterable; - case core::TextureFilterable::kUndefined: - TINT_UNREACHABLE(); - } + return ResourceType::kTexture2d_f32_unknown_filterable; }, [&](const core::type::I32*) { return ResourceType::kTexture2d_i32; }, [&](const core::type::U32*) { return ResourceType::kTexture2d_u32; }, @@ -172,14 +245,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return tint::Switch( sa->Type(), [&](const core::type::F32*) { - switch (sa->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceType::kTexture2dArray_f32_filterable; - case core::TextureFilterable::kUnfilterable: - return ResourceType::kTexture2dArray_f32_unfilterable; - case core::TextureFilterable::kUndefined: - TINT_UNREACHABLE(); - } + return ResourceType::kTexture2dArray_f32_unknown_filterable; }, [&](const core::type::I32*) { return ResourceType::kTexture2dArray_i32; }, [&](const core::type::U32*) { return ResourceType::kTexture2dArray_u32; }, @@ -188,14 +254,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return tint::Switch( sa->Type(), [&](const core::type::F32*) { - switch (sa->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceType::kTexture3d_f32_filterable; - case core::TextureFilterable::kUnfilterable: - return ResourceType::kTexture3d_f32_unfilterable; - case core::TextureFilterable::kUndefined: - TINT_UNREACHABLE(); - } + return ResourceType::kTexture3d_f32_unknown_filterable; }, [&](const core::type::I32*) { return ResourceType::kTexture3d_i32; }, [&](const core::type::U32*) { return ResourceType::kTexture3d_u32; }, @@ -204,14 +263,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return tint::Switch( sa->Type(), [&](const core::type::F32*) { - switch (sa->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceType::kTextureCube_f32_filterable; - case core::TextureFilterable::kUnfilterable: - return ResourceType::kTextureCube_f32_unfilterable; - case core::TextureFilterable::kUndefined: - TINT_UNREACHABLE(); - } + return ResourceType::kTextureCube_f32_unknown_filterable; }, [&](const core::type::I32*) { return ResourceType::kTextureCube_i32; }, [&](const core::type::U32*) { return ResourceType::kTextureCube_u32; }, @@ -220,14 +272,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return tint::Switch( sa->Type(), [&](const core::type::F32*) { - switch (sa->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceType::kTextureCubeArray_f32_filterable; - case core::TextureFilterable::kUnfilterable: - return ResourceType::kTextureCubeArray_f32_unfilterable; - case core::TextureFilterable::kUndefined: - TINT_UNREACHABLE(); - } + return ResourceType::kTextureCubeArray_f32_unknown_filterable; }, [&](const core::type::I32*) { return ResourceType::kTextureCubeArray_i32; }, [&](const core::type::U32*) { return ResourceType::kTextureCubeArray_u32; }, @@ -235,6 +280,7 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { case core::type::TextureDimension::kNone: TINT_UNREACHABLE(); } + TINT_UNREACHABLE(); }, [&](const core::type::MultisampledTexture* ms) { return tint::Switch( @@ -266,49 +312,53 @@ ResourceType TypeToResourceType(const core::type::Type* in_type) { return ResourceType::kSampler_comparison; } - TINT_ASSERT(s->Filtering() != core::SamplerFiltering::kUndefined); - if (s->Filtering() == core::SamplerFiltering::kFiltering) { - return ResourceType::kSampler_filtering; - } - return ResourceType::kSampler_non_filtering; + return ResourceType::kSampler; }, TINT_ICE_ON_NO_MATCH); } std::vector ConvertsFrom(const core::type::Type* in_type) { return tint::Switch( - in_type, + in_type, // [&](const core::type::SampledTexture* sa) -> std::vector { - if (sa->Filterable() != core::TextureFilterable::kUnfilterable) { + if (!sa->Type()->Is()) { return {}; } - TINT_ASSERT((sa->Type()->Is())); switch (sa->Dim()) { case core::type::TextureDimension::k1d: - return {ResourceType::kTexture1d_f32_filterable}; + return {ResourceType::kTexture1d_f32_filterable, + ResourceType::kTexture1d_f32_unfilterable}; case core::type::TextureDimension::k2d: - return {ResourceType::kTexture2d_f32_filterable, ResourceType::kTextureDepth2d}; + return {ResourceType::kTexture2d_f32_filterable, + ResourceType::kTexture2d_f32_unfilterable, + ResourceType::kTextureDepth2d}; case core::type::TextureDimension::k2dArray: return {ResourceType::kTexture2dArray_f32_filterable, + ResourceType::kTexture2dArray_f32_unfilterable, ResourceType::kTextureDepth2dArray}; case core::type::TextureDimension::k3d: - return {ResourceType::kTexture3d_f32_filterable}; + return {ResourceType::kTexture3d_f32_filterable, + ResourceType::kTexture3d_f32_unfilterable}; case core::type::TextureDimension::kCube: return {ResourceType::kTextureCube_f32_filterable, + ResourceType::kTextureCube_f32_unfilterable, ResourceType::kTextureDepthCube}; case core::type::TextureDimension::kCubeArray: - return {ResourceType::kTextureCubeArray_f32_unfilterable, + return {ResourceType::kTextureCubeArray_f32_filterable, + ResourceType::kTextureCubeArray_f32_unfilterable, ResourceType::kTextureDepthCubeArray}; case core::type::TextureDimension::kNone: TINT_UNREACHABLE(); } + + return {}; }, [&](const core::type::Sampler* s) -> std::vector { - if (s->Filtering() == core::SamplerFiltering::kNonFiltering) { - return {ResourceType::kSampler_filtering}; + if (s->IsComparison()) { + return {}; } - return {}; + return {ResourceType::kSampler_filtering, ResourceType::kSampler_non_filtering}; }, [](Default) -> std::vector { return {}; }); } diff --git a/3rdparty/dawn/src/tint/lang/core/type/resource_type.h b/3rdparty/dawn/src/tint/lang/core/type/resource_type.h index 722e5860b..548136591 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/resource_type.h +++ b/3rdparty/dawn/src/tint/lang/core/type/resource_type.h @@ -37,6 +37,9 @@ namespace tint::core::type { // Converts a `in_type` into a resource type ResourceType TypeToResourceType(const core::type::Type* in_type); +// Returns the default resource type for `in_type`. If the `in_type` is an `f32` +// type that could be filterable, the type returns the filterable resource type +ResourceType DefaultResourceTypeFor(const core::type::Type* in_type); // Converts a `ResourceType` back into a `core::type::Type` const core::type::Type* ResourceTypeToType(core::type::Manager& ty, ResourceType type); diff --git a/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.cc b/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.cc index 00ad51263..918c140c5 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.cc @@ -38,12 +38,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::type::SampledTexture); namespace tint::core::type { -SampledTexture::SampledTexture(TextureDimension dim, - const type::Type* type, - TextureFilterable filterable) - : Base(Hash(TypeCode::Of().bits, dim, type, filterable), dim), - type_(type), - filterable_(filterable) { +SampledTexture::SampledTexture(TextureDimension dim, const type::Type* type) + : Base(Hash(TypeCode::Of().bits, dim, type), dim), type_(type) { TINT_ASSERT(type_); } @@ -51,24 +47,20 @@ SampledTexture::~SampledTexture() = default; bool SampledTexture::Equals(const UniqueNode& other) const { if (auto* o = other.As()) { - return o->Dim() == Dim() && o->type_ == type_ && o->filterable_ == filterable_; + return o->Dim() == Dim() && o->type_ == type_; } return false; } std::string SampledTexture::FriendlyName() const { StringStream out; - out << "texture_" << Dim() << "<" << type_->FriendlyName(); - if (filterable_ != TextureFilterable::kUndefined) { - out << ", " << filterable_; - } - out << ">"; + out << "texture_" << Dim() << "<" << type_->FriendlyName() << ">"; return out.str(); } SampledTexture* SampledTexture::Clone(CloneContext& ctx) const { auto* ty = type_->Clone(ctx); - return ctx.dst.mgr->Get(Dim(), ty, filterable_); + return ctx.dst.mgr->Get(Dim(), ty); } } // namespace tint::core::type diff --git a/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.h b/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.h index 204e9ff3f..27d55863e 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.h +++ b/3rdparty/dawn/src/tint/lang/core/type/sampled_texture.h @@ -30,7 +30,6 @@ #include -#include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/type/texture.h" #include "src/tint/lang/core/type/texture_dimension.h" @@ -42,10 +41,7 @@ class SampledTexture final : public Castable { /// Constructor /// @param dim the dimensionality of the texture /// @param type the data type of the sampled texture - /// @param filterable the texture filterability - SampledTexture(TextureDimension dim, - const type::Type* type, - TextureFilterable filterable = TextureFilterable::kUndefined); + SampledTexture(TextureDimension dim, const type::Type* type); /// Destructor ~SampledTexture() override; @@ -57,9 +53,6 @@ class SampledTexture final : public Castable { /// @returns the subtype of the sampled texture const type::Type* Type() const { return type_; } - /// @returns the filterability - TextureFilterable Filterable() const { return filterable_; } - /// @returns the name for this type that closely resembles how it would be /// declared in WGSL. std::string FriendlyName() const override; @@ -70,7 +63,6 @@ class SampledTexture final : public Castable { private: const type::Type* type_; - TextureFilterable filterable_; }; } // namespace tint::core::type diff --git a/3rdparty/dawn/src/tint/lang/core/type/sampler.cc b/3rdparty/dawn/src/tint/lang/core/type/sampler.cc index d4ab21974..e70c368ca 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/sampler.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/sampler.cc @@ -34,16 +34,14 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::type::Sampler); namespace tint::core::type { -Sampler::Sampler(SamplerKind kind, SamplerFiltering filtering) - : Base(Hash(tint::TypeCode::Of().bits, kind, filtering), core::type::Flags{}), - kind_(kind), - filtering_(filtering) {} +Sampler::Sampler(SamplerKind kind) + : Base(Hash(tint::TypeCode::Of().bits, kind), core::type::Flags{}), kind_(kind) {} Sampler::~Sampler() = default; bool Sampler::Equals(const UniqueNode& other) const { if (auto* o = other.As()) { - return o->kind_ == kind_ && o->filtering_ == filtering_; + return o->kind_ == kind_; } return false; } @@ -56,14 +54,11 @@ std::string Sampler::FriendlyName() const { if (kind_ == SamplerKind::kComparisonSampler) { return "sampler_comparison"; } - if (filtering_ == SamplerFiltering::kUndefined) { - return "sampler"; - } - return "sampler<" + std::string(ToString(filtering_)) + ">"; + return "sampler"; } Sampler* Sampler::Clone(CloneContext& ctx) const { - return ctx.dst.mgr->Get(kind_, filtering_); + return ctx.dst.mgr->Get(kind_); } } // namespace tint::core::type diff --git a/3rdparty/dawn/src/tint/lang/core/type/sampler.h b/3rdparty/dawn/src/tint/lang/core/type/sampler.h index c84878358..9a9473e60 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/sampler.h +++ b/3rdparty/dawn/src/tint/lang/core/type/sampler.h @@ -30,7 +30,6 @@ #include -#include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/type/sampler_kind.h" #include "src/tint/lang/core/type/type.h" @@ -41,8 +40,7 @@ class Sampler final : public Castable { public: /// Constructor /// @param kind the kind of sampler - /// @param filtering the filtering flag - explicit Sampler(SamplerKind kind, SamplerFiltering filtering = SamplerFiltering::kUndefined); + explicit Sampler(SamplerKind kind); /// Destructor ~Sampler() override; @@ -54,9 +52,6 @@ class Sampler final : public Castable { /// @returns the sampler type SamplerKind Kind() const { return kind_; } - /// @returns the sampler Filtering - SamplerFiltering Filtering() const { return filtering_; } - /// @returns true if this is a comparison sampler bool IsComparison() const { return kind_ == SamplerKind::kComparisonSampler; } @@ -73,7 +68,6 @@ class Sampler final : public Castable { private: SamplerKind const kind_; - SamplerFiltering filtering_; }; } // namespace tint::core::type diff --git a/3rdparty/dawn/src/tint/lang/core/type/struct.cc b/3rdparty/dawn/src/tint/lang/core/type/struct.cc index 728c540b3..6db3275d2 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/struct.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/struct.cc @@ -38,6 +38,7 @@ #include "src/tint/lang/core/type/array_count.h" #include "src/tint/lang/core/type/manager.h" #include "src/tint/lang/core/type/matrix.h" +#include "src/tint/utils/internal_limits.h" #include "src/tint/utils/math/hash.h" #include "src/tint/utils/symbol/symbol_table.h" #include "src/tint/utils/text/string_stream.h" @@ -225,6 +226,28 @@ uint32_t Struct::SizeNoPadding() const { return mem->Offset() + mem->Size(); } +Result Struct::PaddingWithinLimit() const { + uint32_t cur_offset = 0; + for (auto* member : members_) { + uint32_t padding = member->Offset() - cur_offset; + if (padding >= tint::internal_limits::kMaxStructMemberPadding) { + return Failure{"struct member padding (" + std::to_string(padding) + + ") is larger than the maximum (" + + std::to_string(tint::internal_limits::kMaxStructMemberPadding) + ")"}; + } + cur_offset += padding + member->MinimumRequiredSize(); + } + + uint32_t end_padding = Size() - cur_offset; + if (end_padding >= tint::internal_limits::kMaxStructMemberPadding) { + return Failure{"struct padding (" + std::to_string(end_padding) + + ") is larger than the maximum (" + + std::to_string(tint::internal_limits::kMaxStructMemberPadding) + ")"}; + } + + return Success; +} + Struct* Struct::Clone(CloneContext& ctx) const { auto sym = ctx.dst.st->Register(name_.Name()); diff --git a/3rdparty/dawn/src/tint/lang/core/type/struct.h b/3rdparty/dawn/src/tint/lang/core/type/struct.h index 6f99db757..3cb4ae9ab 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/struct.h +++ b/3rdparty/dawn/src/tint/lang/core/type/struct.h @@ -40,6 +40,7 @@ #include "src/tint/lang/core/type/type.h" #include "src/tint/utils/containers/hashset.h" #include "src/tint/utils/containers/vector.h" +#include "src/tint/utils/result.h" #include "src/tint/utils/symbol/symbol.h" #include "src/tint/utils/text/styled_text.h" @@ -129,6 +130,10 @@ class Struct : public Castable { /// alignment padding uint32_t SizeNoPadding() const; + /// @returns success if the structure has no excessive padding between members or at the end, + /// otherwise a Failure reason + Result PaddingWithinLimit() const; + /// @returns the structure flags core::type::StructFlags StructFlags() const { return struct_flags_; } diff --git a/3rdparty/dawn/src/tint/lang/core/type/u8.cc b/3rdparty/dawn/src/tint/lang/core/type/u8.cc index 36dd4cd1f..68bf7f52f 100644 --- a/3rdparty/dawn/src/tint/lang/core/type/u8.cc +++ b/3rdparty/dawn/src/tint/lang/core/type/u8.cc @@ -39,6 +39,7 @@ U8::U8() Flag::kConstructable, Flag::kCreationFixedFootprint, Flag::kFixedFootprint, + Flag::kHostShareable, }) {} U8::~U8() = default; diff --git a/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.cc b/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.cc index 180f0fab4..7db8d5b56 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.cc @@ -264,6 +264,10 @@ const char* str(BuiltinFn i) { return "group_non_uniform_s_min"; case BuiltinFn::kGroupNonUniformSMax: return "group_non_uniform_s_max"; + case BuiltinFn::kInterpolateAtOffset: + return "interpolate_at_offset"; + case BuiltinFn::kAddCarry: + return "add_carry"; } return ""; } @@ -385,8 +389,10 @@ tint::core::ir::Instruction::Accesses GetSideEffects(BuiltinFn fn) { case BuiltinFn::kGroupNonUniformQuadSwap: case BuiltinFn::kGroupNonUniformSMin: case BuiltinFn::kGroupNonUniformSMax: + case BuiltinFn::kInterpolateAtOffset: case BuiltinFn::kSConvert: case BuiltinFn::kUConvert: + case BuiltinFn::kAddCarry: break; } return core::ir::Instruction::Accesses{}; diff --git a/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.h b/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.h index d7cd68e71..91aa2af77 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.h +++ b/3rdparty/dawn/src/tint/lang/spirv/builtin_fn.h @@ -160,6 +160,8 @@ enum class BuiltinFn : uint8_t { kGroupNonUniformShuffleUp, kGroupNonUniformSMin, kGroupNonUniformSMax, + kInterpolateAtOffset, + kAddCarry, kNone, }; diff --git a/3rdparty/dawn/src/tint/lang/spirv/intrinsic/data.cc b/3rdparty/dawn/src/tint/lang/spirv/intrinsic/data.cc index 52da4fd94..0d3afe0d3 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/intrinsic/data.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/intrinsic/data.cc @@ -505,6 +505,20 @@ constexpr TypeMatcher kAtomicMatcher { }; +/// TypeMatcher for 'type literal' +constexpr TypeMatcher kLiteralMatcher { +/* match */ [](MatchState& state, const Type* ty) -> const Type* { + if (!MatchLiteral(state, ty)) { + return nullptr; + } + return BuildLiteral(state, ty); + }, +/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) { + out << style::Type("literal"); + } +}; + + /// TypeMatcher for 'type sampler' constexpr TypeMatcher kSamplerMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -519,26 +533,6 @@ constexpr TypeMatcher kSamplerMatcher { }; -/// TypeMatcher for 'type sampler_filtered' -constexpr TypeMatcher kSamplerFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - Number F = Number::invalid; - if (!MatchSamplerFiltered(state, ty, F)) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildSamplerFiltered(state, ty, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F; - state->PrintNum(F); - out << style::Type("sampler<", F, ">"); - } -}; - - /// TypeMatcher for 'type sampler_comparison' constexpr TypeMatcher kSamplerComparisonMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -599,6 +593,52 @@ constexpr TypeMatcher kStructWithRuntimeArrayMatcher { }; +/// TypeMatcher for 'type struct_add_carry_scalar' +constexpr TypeMatcher kStructAddCarryScalarMatcher { +/* match */ [](MatchState& state, const Type* ty) -> const Type* { + const Type* T = nullptr; + if (!MatchStructAddCarryScalar(state, ty, T)) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return BuildStructAddCarryScalar(state, ty, T); + }, +/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; + state->PrintType(T); + out << style::Type("struct_add_carry_scalar", "<", T, ">"); + } +}; + + +/// TypeMatcher for 'type struct_add_carry_vec' +constexpr TypeMatcher kStructAddCarryVecMatcher { +/* match */ [](MatchState& state, const Type* ty) -> const Type* { + Number N = Number::invalid; + const Type* T = nullptr; + if (!MatchStructAddCarryVec(state, ty, N, T)) { + return nullptr; + } + N = state.Num(N); + if (!N.IsValid()) { + return nullptr; + } + T = state.Type(T); + if (T == nullptr) { + return nullptr; + } + return BuildStructAddCarryVec(state, ty, N, T); + }, +/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText N; + state->PrintNum(N);StyledText T; + state->PrintType(T); + out << style::Type("struct_add_carry_vec", "<", N, ", ", T, ">"); + } +}; + + /// TypeMatcher for 'type image' constexpr TypeMatcher kImageMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -879,90 +919,6 @@ constexpr TypeMatcher kSamplersMatcher { kSamplerMatcher.print(nullptr, out); out << style::Plain(" or "); kSamplerComparisonMatcher.print(nullptr, out);} }; -/// EnumMatcher for 'match filterable' -constexpr NumberMatcher kFilterableMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::TextureFilterable::kFilterable)) { - return Number(static_cast(core::TextureFilterable::kFilterable)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filterable"); - } -}; - -/// EnumMatcher for 'match unfilterable' -constexpr NumberMatcher kUnfilterableMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::TextureFilterable::kUnfilterable)) { - return Number(static_cast(core::TextureFilterable::kUnfilterable)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("unfilterable"); - } -}; - -/// EnumMatcher for 'match filtering' -constexpr NumberMatcher kFilteringMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::SamplerFiltering::kFiltering)) { - return Number(static_cast(core::SamplerFiltering::kFiltering)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filtering"); - } -}; - -/// EnumMatcher for 'match non_filtering' -constexpr NumberMatcher kNonFilteringMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::SamplerFiltering::kNonFiltering)) { - return Number(static_cast(core::SamplerFiltering::kNonFiltering)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("non_filtering"); - } -}; - -/// EnumMatcher for 'match texture_filter' -constexpr NumberMatcher kTextureFilterMatcher { -/* match */ [](MatchState&, Number number) -> Number { - switch (static_cast(number.Value())) { - case core::TextureFilterable::kFilterable: - case core::TextureFilterable::kUnfilterable: - return number; - default: - return Number::invalid; - } - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filterable")<< style::Plain(" or ") << style::Enum("unfilterable"); - } -}; - -/// EnumMatcher for 'match sampler_filter' -constexpr NumberMatcher kSamplerFilterMatcher { -/* match */ [](MatchState&, Number number) -> Number { - switch (static_cast(number.Value())) { - case core::SamplerFiltering::kFiltering: - case core::SamplerFiltering::kNonFiltering: - return number; - default: - return Number::invalid; - } - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filtering")<< style::Plain(" or ") << style::Enum("non_filtering"); - } -}; - /// EnumMatcher for 'match storage' constexpr NumberMatcher kStorageMatcher { /* match */ [](MatchState&, Number number) -> Number { @@ -976,6 +932,19 @@ constexpr NumberMatcher kStorageMatcher { } }; +/// EnumMatcher for 'match in' +constexpr NumberMatcher kInMatcher { +/* match */ [](MatchState&, Number number) -> Number { + if (number.IsAny() || number.Value() == static_cast(core::AddressSpace::kIn)) { + return Number(static_cast(core::AddressSpace::kIn)); + } + return Number::invalid; + }, +/* print */ [](MatchState*, StyledText& out) { + out<< style::Enum("__in"); + } +}; + /// EnumMatcher for 'match workgroup_or_storage' constexpr NumberMatcher kWorkgroupOrStorageMatcher { /* match */ [](MatchState&, Number number) -> Number { @@ -1446,22 +1415,24 @@ constexpr TypeMatcher kTypeMatchers[] = { /* [27] */ kVecMatcher, /* [28] */ kMatMatcher, /* [29] */ kAtomicMatcher, - /* [30] */ kSamplerMatcher, - /* [31] */ kSamplerFilteredMatcher, + /* [30] */ kLiteralMatcher, + /* [31] */ kSamplerMatcher, /* [32] */ kSamplerComparisonMatcher, /* [33] */ kPtrMatcher, /* [34] */ kStructWithRuntimeArrayMatcher, - /* [35] */ kImageMatcher, - /* [36] */ kSampledImageMatcher, - /* [37] */ kSubgroupMatrixMatcher, - /* [38] */ kF32F16Matcher, - /* [39] */ kIu32Matcher, - /* [40] */ kFiu32Matcher, - /* [41] */ kFiu32F16Matcher, - /* [42] */ kScalarMatcher, - /* [43] */ kIu32Iu8Matcher, - /* [44] */ kIu8Matcher, - /* [45] */ kSamplersMatcher, + /* [35] */ kStructAddCarryScalarMatcher, + /* [36] */ kStructAddCarryVecMatcher, + /* [37] */ kImageMatcher, + /* [38] */ kSampledImageMatcher, + /* [39] */ kSubgroupMatrixMatcher, + /* [40] */ kF32F16Matcher, + /* [41] */ kIu32Matcher, + /* [42] */ kFiu32Matcher, + /* [43] */ kFiu32F16Matcher, + /* [44] */ kScalarMatcher, + /* [45] */ kIu32Iu8Matcher, + /* [46] */ kIu8Matcher, + /* [47] */ kSamplersMatcher, }; /// The template numbers, and number matchers @@ -1473,1221 +1444,1233 @@ constexpr NumberMatcher kNumberMatchers[] = { /* [4] */ TemplateNumberMatcher<4>::matcher, /* [5] */ TemplateNumberMatcher<5>::matcher, /* [6] */ TemplateNumberMatcher<6>::matcher, - /* [7] */ kFilterableMatcher, - /* [8] */ kUnfilterableMatcher, - /* [9] */ kFilteringMatcher, - /* [10] */ kNonFilteringMatcher, - /* [11] */ kTextureFilterMatcher, - /* [12] */ kSamplerFilterMatcher, - /* [13] */ kStorageMatcher, - /* [14] */ kWorkgroupOrStorageMatcher, - /* [15] */ kFunctionPrivateWorkgroupStorageMatcher, - /* [16] */ kF32TexelFormatMatcher, - /* [17] */ kI32TexelFormatMatcher, - /* [18] */ kU32TexelFormatMatcher, - /* [19] */ kReadWriteMatcher, - /* [20] */ kReadableMatcher, - /* [21] */ kWritableMatcher, - /* [22] */ kDim1DMatcher, - /* [23] */ kDim2DMatcher, - /* [24] */ kDim3DMatcher, - /* [25] */ kDimCubeMatcher, - /* [26] */ kDimBufferMatcher, - /* [27] */ kDimSubpassMatcher, - /* [28] */ kDim1D2D3DOrCubeMatcher, - /* [29] */ kSingleSampledMatcher, - /* [30] */ kMultiSampledMatcher, - /* [31] */ kIsDepthMatcher, - /* [32] */ kNonDepthMatcher, - /* [33] */ kAnyDepthMatcher, - /* [34] */ kIsArrayedMatcher, - /* [35] */ kNonArrayedMatcher, - /* [36] */ kAnyArrayedMatcher, - /* [37] */ kSamplingCompatibleMatcher, - /* [38] */ kRwOpCompatibleMatcher, - /* [39] */ kSubgroupMatrixKindLeftMatcher, - /* [40] */ kSubgroupMatrixKindRightMatcher, - /* [41] */ kSubgroupMatrixKindResultMatcher, + /* [7] */ kStorageMatcher, + /* [8] */ kInMatcher, + /* [9] */ kWorkgroupOrStorageMatcher, + /* [10] */ kFunctionPrivateWorkgroupStorageMatcher, + /* [11] */ kF32TexelFormatMatcher, + /* [12] */ kI32TexelFormatMatcher, + /* [13] */ kU32TexelFormatMatcher, + /* [14] */ kReadWriteMatcher, + /* [15] */ kReadableMatcher, + /* [16] */ kWritableMatcher, + /* [17] */ kDim1DMatcher, + /* [18] */ kDim2DMatcher, + /* [19] */ kDim3DMatcher, + /* [20] */ kDimCubeMatcher, + /* [21] */ kDimBufferMatcher, + /* [22] */ kDimSubpassMatcher, + /* [23] */ kDim1D2D3DOrCubeMatcher, + /* [24] */ kSingleSampledMatcher, + /* [25] */ kMultiSampledMatcher, + /* [26] */ kIsDepthMatcher, + /* [27] */ kNonDepthMatcher, + /* [28] */ kAnyDepthMatcher, + /* [29] */ kIsArrayedMatcher, + /* [30] */ kNonArrayedMatcher, + /* [31] */ kAnyArrayedMatcher, + /* [32] */ kSamplingCompatibleMatcher, + /* [33] */ kRwOpCompatibleMatcher, + /* [34] */ kSubgroupMatrixKindLeftMatcher, + /* [35] */ kSubgroupMatrixKindRightMatcher, + /* [36] */ kSubgroupMatrixKindResultMatcher, }; constexpr MatcherIndex kMatcherIndices[] = { - /* [0] */ MatcherIndex(36), - /* [1] */ MatcherIndex(35), + /* [0] */ MatcherIndex(38), + /* [1] */ MatcherIndex(37), /* [2] */ MatcherIndex(8), - /* [3] */ MatcherIndex(23), - /* [4] */ MatcherIndex(33), - /* [5] */ MatcherIndex(35), - /* [6] */ MatcherIndex(29), - /* [7] */ MatcherIndex(37), + /* [3] */ MatcherIndex(18), + /* [4] */ MatcherIndex(28), + /* [5] */ MatcherIndex(30), + /* [6] */ MatcherIndex(24), + /* [7] */ MatcherIndex(32), /* [8] */ MatcherIndex(0), - /* [9] */ MatcherIndex(20), - /* [10] */ MatcherIndex(36), - /* [11] */ MatcherIndex(35), - /* [12] */ MatcherIndex(8), - /* [13] */ MatcherIndex(23), - /* [14] */ MatcherIndex(33), - /* [15] */ MatcherIndex(34), + /* [9] */ MatcherIndex(15), + /* [10] */ MatcherIndex(8), + /* [11] */ MatcherIndex(38), + /* [12] */ MatcherIndex(37), + /* [13] */ MatcherIndex(8), + /* [14] */ MatcherIndex(18), + /* [15] */ MatcherIndex(28), /* [16] */ MatcherIndex(29), - /* [17] */ MatcherIndex(37), - /* [18] */ MatcherIndex(0), - /* [19] */ MatcherIndex(20), - /* [20] */ MatcherIndex(36), - /* [21] */ MatcherIndex(35), - /* [22] */ MatcherIndex(8), - /* [23] */ MatcherIndex(25), - /* [24] */ MatcherIndex(33), - /* [25] */ MatcherIndex(35), - /* [26] */ MatcherIndex(29), - /* [27] */ MatcherIndex(37), - /* [28] */ MatcherIndex(0), - /* [29] */ MatcherIndex(20), - /* [30] */ MatcherIndex(36), - /* [31] */ MatcherIndex(35), - /* [32] */ MatcherIndex(8), - /* [33] */ MatcherIndex(25), - /* [34] */ MatcherIndex(33), - /* [35] */ MatcherIndex(34), - /* [36] */ MatcherIndex(29), - /* [37] */ MatcherIndex(37), - /* [38] */ MatcherIndex(0), - /* [39] */ MatcherIndex(20), - /* [40] */ MatcherIndex(36), - /* [41] */ MatcherIndex(35), - /* [42] */ MatcherIndex(0), - /* [43] */ MatcherIndex(23), - /* [44] */ MatcherIndex(32), - /* [45] */ MatcherIndex(35), - /* [46] */ MatcherIndex(29), - /* [47] */ MatcherIndex(37), - /* [48] */ MatcherIndex(2), - /* [49] */ MatcherIndex(20), - /* [50] */ MatcherIndex(36), - /* [51] */ MatcherIndex(35), - /* [52] */ MatcherIndex(0), - /* [53] */ MatcherIndex(23), - /* [54] */ MatcherIndex(32), - /* [55] */ MatcherIndex(35), - /* [56] */ MatcherIndex(29), - /* [57] */ MatcherIndex(37), - /* [58] */ MatcherIndex(3), - /* [59] */ MatcherIndex(20), - /* [60] */ MatcherIndex(36), - /* [61] */ MatcherIndex(35), - /* [62] */ MatcherIndex(0), - /* [63] */ MatcherIndex(23), - /* [64] */ MatcherIndex(32), - /* [65] */ MatcherIndex(34), - /* [66] */ MatcherIndex(29), - /* [67] */ MatcherIndex(37), - /* [68] */ MatcherIndex(2), - /* [69] */ MatcherIndex(20), - /* [70] */ MatcherIndex(36), - /* [71] */ MatcherIndex(35), - /* [72] */ MatcherIndex(0), - /* [73] */ MatcherIndex(23), - /* [74] */ MatcherIndex(32), - /* [75] */ MatcherIndex(34), - /* [76] */ MatcherIndex(29), - /* [77] */ MatcherIndex(37), - /* [78] */ MatcherIndex(3), - /* [79] */ MatcherIndex(20), - /* [80] */ MatcherIndex(36), - /* [81] */ MatcherIndex(35), - /* [82] */ MatcherIndex(0), - /* [83] */ MatcherIndex(25), - /* [84] */ MatcherIndex(32), - /* [85] */ MatcherIndex(35), - /* [86] */ MatcherIndex(29), - /* [87] */ MatcherIndex(37), - /* [88] */ MatcherIndex(2), - /* [89] */ MatcherIndex(20), - /* [90] */ MatcherIndex(36), - /* [91] */ MatcherIndex(35), - /* [92] */ MatcherIndex(0), - /* [93] */ MatcherIndex(25), - /* [94] */ MatcherIndex(32), - /* [95] */ MatcherIndex(34), - /* [96] */ MatcherIndex(29), - /* [97] */ MatcherIndex(37), - /* [98] */ MatcherIndex(2), - /* [99] */ MatcherIndex(20), - /* [100] */ MatcherIndex(36), - /* [101] */ MatcherIndex(35), - /* [102] */ MatcherIndex(8), - /* [103] */ MatcherIndex(23), - /* [104] */ MatcherIndex(31), - /* [105] */ MatcherIndex(35), - /* [106] */ MatcherIndex(29), - /* [107] */ MatcherIndex(37), - /* [108] */ MatcherIndex(1), - /* [109] */ MatcherIndex(20), - /* [110] */ MatcherIndex(36), - /* [111] */ MatcherIndex(35), - /* [112] */ MatcherIndex(8), - /* [113] */ MatcherIndex(23), - /* [114] */ MatcherIndex(31), - /* [115] */ MatcherIndex(35), - /* [116] */ MatcherIndex(29), - /* [117] */ MatcherIndex(37), - /* [118] */ MatcherIndex(2), - /* [119] */ MatcherIndex(20), - /* [120] */ MatcherIndex(36), - /* [121] */ MatcherIndex(35), - /* [122] */ MatcherIndex(8), - /* [123] */ MatcherIndex(23), - /* [124] */ MatcherIndex(31), - /* [125] */ MatcherIndex(34), - /* [126] */ MatcherIndex(29), - /* [127] */ MatcherIndex(37), - /* [128] */ MatcherIndex(1), - /* [129] */ MatcherIndex(20), - /* [130] */ MatcherIndex(36), - /* [131] */ MatcherIndex(35), - /* [132] */ MatcherIndex(8), - /* [133] */ MatcherIndex(23), - /* [134] */ MatcherIndex(31), - /* [135] */ MatcherIndex(34), - /* [136] */ MatcherIndex(29), - /* [137] */ MatcherIndex(37), - /* [138] */ MatcherIndex(2), - /* [139] */ MatcherIndex(20), - /* [140] */ MatcherIndex(36), - /* [141] */ MatcherIndex(35), - /* [142] */ MatcherIndex(8), - /* [143] */ MatcherIndex(25), - /* [144] */ MatcherIndex(31), - /* [145] */ MatcherIndex(35), - /* [146] */ MatcherIndex(29), - /* [147] */ MatcherIndex(37), - /* [148] */ MatcherIndex(1), - /* [149] */ MatcherIndex(20), - /* [150] */ MatcherIndex(36), - /* [151] */ MatcherIndex(35), - /* [152] */ MatcherIndex(8), - /* [153] */ MatcherIndex(25), - /* [154] */ MatcherIndex(31), - /* [155] */ MatcherIndex(34), - /* [156] */ MatcherIndex(29), - /* [157] */ MatcherIndex(37), - /* [158] */ MatcherIndex(1), - /* [159] */ MatcherIndex(20), - /* [160] */ MatcherIndex(36), - /* [161] */ MatcherIndex(35), - /* [162] */ MatcherIndex(0), - /* [163] */ MatcherIndex(22), - /* [164] */ MatcherIndex(32), - /* [165] */ MatcherIndex(35), - /* [166] */ MatcherIndex(29), - /* [167] */ MatcherIndex(37), - /* [168] */ MatcherIndex(1), - /* [169] */ MatcherIndex(20), - /* [170] */ MatcherIndex(36), - /* [171] */ MatcherIndex(35), - /* [172] */ MatcherIndex(0), - /* [173] */ MatcherIndex(23), - /* [174] */ MatcherIndex(32), - /* [175] */ MatcherIndex(35), - /* [176] */ MatcherIndex(29), - /* [177] */ MatcherIndex(37), - /* [178] */ MatcherIndex(1), - /* [179] */ MatcherIndex(20), - /* [180] */ MatcherIndex(36), - /* [181] */ MatcherIndex(35), - /* [182] */ MatcherIndex(0), - /* [183] */ MatcherIndex(23), - /* [184] */ MatcherIndex(32), - /* [185] */ MatcherIndex(34), - /* [186] */ MatcherIndex(29), - /* [187] */ MatcherIndex(37), - /* [188] */ MatcherIndex(1), - /* [189] */ MatcherIndex(20), - /* [190] */ MatcherIndex(36), - /* [191] */ MatcherIndex(35), - /* [192] */ MatcherIndex(0), - /* [193] */ MatcherIndex(24), - /* [194] */ MatcherIndex(32), - /* [195] */ MatcherIndex(35), - /* [196] */ MatcherIndex(29), - /* [197] */ MatcherIndex(37), - /* [198] */ MatcherIndex(1), - /* [199] */ MatcherIndex(20), - /* [200] */ MatcherIndex(36), - /* [201] */ MatcherIndex(35), - /* [202] */ MatcherIndex(0), - /* [203] */ MatcherIndex(24), - /* [204] */ MatcherIndex(32), - /* [205] */ MatcherIndex(35), - /* [206] */ MatcherIndex(29), - /* [207] */ MatcherIndex(37), - /* [208] */ MatcherIndex(2), - /* [209] */ MatcherIndex(20), - /* [210] */ MatcherIndex(36), - /* [211] */ MatcherIndex(35), - /* [212] */ MatcherIndex(0), - /* [213] */ MatcherIndex(25), - /* [214] */ MatcherIndex(32), - /* [215] */ MatcherIndex(35), - /* [216] */ MatcherIndex(29), - /* [217] */ MatcherIndex(37), - /* [218] */ MatcherIndex(1), - /* [219] */ MatcherIndex(20), - /* [220] */ MatcherIndex(36), - /* [221] */ MatcherIndex(35), - /* [222] */ MatcherIndex(0), - /* [223] */ MatcherIndex(25), - /* [224] */ MatcherIndex(32), - /* [225] */ MatcherIndex(34), - /* [226] */ MatcherIndex(29), - /* [227] */ MatcherIndex(37), - /* [228] */ MatcherIndex(1), - /* [229] */ MatcherIndex(20), - /* [230] */ MatcherIndex(36), - /* [231] */ MatcherIndex(35), - /* [232] */ MatcherIndex(8), - /* [233] */ MatcherIndex(23), - /* [234] */ MatcherIndex(31), - /* [235] */ MatcherIndex(35), - /* [236] */ MatcherIndex(29), - /* [237] */ MatcherIndex(37), - /* [238] */ MatcherIndex(0), - /* [239] */ MatcherIndex(20), - /* [240] */ MatcherIndex(36), - /* [241] */ MatcherIndex(35), - /* [242] */ MatcherIndex(8), - /* [243] */ MatcherIndex(25), - /* [244] */ MatcherIndex(31), - /* [245] */ MatcherIndex(35), - /* [246] */ MatcherIndex(29), - /* [247] */ MatcherIndex(37), - /* [248] */ MatcherIndex(0), - /* [249] */ MatcherIndex(20), - /* [250] */ MatcherIndex(36), - /* [251] */ MatcherIndex(35), - /* [252] */ MatcherIndex(8), - /* [253] */ MatcherIndex(23), - /* [254] */ MatcherIndex(31), - /* [255] */ MatcherIndex(34), - /* [256] */ MatcherIndex(29), - /* [257] */ MatcherIndex(37), - /* [258] */ MatcherIndex(0), - /* [259] */ MatcherIndex(20), - /* [260] */ MatcherIndex(36), - /* [261] */ MatcherIndex(35), - /* [262] */ MatcherIndex(8), - /* [263] */ MatcherIndex(25), - /* [264] */ MatcherIndex(31), - /* [265] */ MatcherIndex(34), - /* [266] */ MatcherIndex(29), - /* [267] */ MatcherIndex(37), - /* [268] */ MatcherIndex(0), - /* [269] */ MatcherIndex(20), - /* [270] */ MatcherIndex(36), - /* [271] */ MatcherIndex(35), - /* [272] */ MatcherIndex(8), - /* [273] */ MatcherIndex(23), - /* [274] */ MatcherIndex(33), - /* [275] */ MatcherIndex(35), - /* [276] */ MatcherIndex(29), - /* [277] */ MatcherIndex(37), - /* [278] */ MatcherIndex(1), - /* [279] */ MatcherIndex(20), - /* [280] */ MatcherIndex(36), - /* [281] */ MatcherIndex(35), - /* [282] */ MatcherIndex(8), - /* [283] */ MatcherIndex(23), - /* [284] */ MatcherIndex(33), - /* [285] */ MatcherIndex(34), - /* [286] */ MatcherIndex(29), - /* [287] */ MatcherIndex(37), - /* [288] */ MatcherIndex(1), - /* [289] */ MatcherIndex(20), - /* [290] */ MatcherIndex(35), - /* [291] */ MatcherIndex(0), - /* [292] */ MatcherIndex(22), - /* [293] */ MatcherIndex(32), - /* [294] */ MatcherIndex(35), - /* [295] */ MatcherIndex(29), - /* [296] */ MatcherIndex(37), - /* [297] */ MatcherIndex(2), - /* [298] */ MatcherIndex(20), - /* [299] */ MatcherIndex(35), - /* [300] */ MatcherIndex(0), - /* [301] */ MatcherIndex(23), - /* [302] */ MatcherIndex(32), - /* [303] */ MatcherIndex(35), - /* [304] */ MatcherIndex(30), - /* [305] */ MatcherIndex(37), - /* [306] */ MatcherIndex(2), - /* [307] */ MatcherIndex(20), - /* [308] */ MatcherIndex(35), - /* [309] */ MatcherIndex(8), - /* [310] */ MatcherIndex(23), - /* [311] */ MatcherIndex(31), - /* [312] */ MatcherIndex(35), - /* [313] */ MatcherIndex(30), - /* [314] */ MatcherIndex(37), - /* [315] */ MatcherIndex(1), - /* [316] */ MatcherIndex(20), - /* [317] */ MatcherIndex(35), - /* [318] */ MatcherIndex(0), - /* [319] */ MatcherIndex(22), - /* [320] */ MatcherIndex(32), - /* [321] */ MatcherIndex(35), - /* [322] */ MatcherIndex(29), - /* [323] */ MatcherIndex(37), - /* [324] */ MatcherIndex(3), - /* [325] */ MatcherIndex(20), - /* [326] */ MatcherIndex(35), - /* [327] */ MatcherIndex(0), - /* [328] */ MatcherIndex(24), - /* [329] */ MatcherIndex(32), - /* [330] */ MatcherIndex(35), - /* [331] */ MatcherIndex(29), - /* [332] */ MatcherIndex(37), - /* [333] */ MatcherIndex(3), - /* [334] */ MatcherIndex(20), - /* [335] */ MatcherIndex(35), - /* [336] */ MatcherIndex(0), - /* [337] */ MatcherIndex(23), - /* [338] */ MatcherIndex(32), - /* [339] */ MatcherIndex(35), - /* [340] */ MatcherIndex(30), - /* [341] */ MatcherIndex(37), - /* [342] */ MatcherIndex(3), - /* [343] */ MatcherIndex(20), - /* [344] */ MatcherIndex(35), - /* [345] */ MatcherIndex(8), - /* [346] */ MatcherIndex(23), - /* [347] */ MatcherIndex(31), - /* [348] */ MatcherIndex(35), - /* [349] */ MatcherIndex(30), - /* [350] */ MatcherIndex(37), - /* [351] */ MatcherIndex(2), - /* [352] */ MatcherIndex(20), - /* [353] */ MatcherIndex(35), - /* [354] */ MatcherIndex(1), - /* [355] */ MatcherIndex(22), - /* [356] */ MatcherIndex(32), - /* [357] */ MatcherIndex(35), - /* [358] */ MatcherIndex(29), - /* [359] */ MatcherIndex(38), - /* [360] */ MatcherIndex(2), - /* [361] */ MatcherIndex(3), - /* [362] */ MatcherIndex(35), - /* [363] */ MatcherIndex(1), - /* [364] */ MatcherIndex(26), - /* [365] */ MatcherIndex(32), - /* [366] */ MatcherIndex(35), - /* [367] */ MatcherIndex(29), - /* [368] */ MatcherIndex(38), - /* [369] */ MatcherIndex(2), - /* [370] */ MatcherIndex(3), - /* [371] */ MatcherIndex(35), - /* [372] */ MatcherIndex(1), - /* [373] */ MatcherIndex(23), - /* [374] */ MatcherIndex(32), - /* [375] */ MatcherIndex(35), - /* [376] */ MatcherIndex(29), - /* [377] */ MatcherIndex(38), - /* [378] */ MatcherIndex(2), - /* [379] */ MatcherIndex(3), - /* [380] */ MatcherIndex(35), - /* [381] */ MatcherIndex(1), - /* [382] */ MatcherIndex(23), - /* [383] */ MatcherIndex(32), - /* [384] */ MatcherIndex(34), - /* [385] */ MatcherIndex(29), - /* [386] */ MatcherIndex(38), - /* [387] */ MatcherIndex(2), - /* [388] */ MatcherIndex(3), - /* [389] */ MatcherIndex(35), - /* [390] */ MatcherIndex(1), - /* [391] */ MatcherIndex(24), - /* [392] */ MatcherIndex(32), - /* [393] */ MatcherIndex(35), - /* [394] */ MatcherIndex(29), - /* [395] */ MatcherIndex(38), - /* [396] */ MatcherIndex(2), - /* [397] */ MatcherIndex(3), - /* [398] */ MatcherIndex(35), - /* [399] */ MatcherIndex(1), - /* [400] */ MatcherIndex(25), - /* [401] */ MatcherIndex(32), - /* [402] */ MatcherIndex(35), - /* [403] */ MatcherIndex(29), - /* [404] */ MatcherIndex(38), - /* [405] */ MatcherIndex(2), - /* [406] */ MatcherIndex(3), - /* [407] */ MatcherIndex(35), - /* [408] */ MatcherIndex(1), - /* [409] */ MatcherIndex(25), - /* [410] */ MatcherIndex(32), - /* [411] */ MatcherIndex(34), - /* [412] */ MatcherIndex(29), - /* [413] */ MatcherIndex(38), - /* [414] */ MatcherIndex(2), - /* [415] */ MatcherIndex(3), - /* [416] */ MatcherIndex(35), - /* [417] */ MatcherIndex(1), - /* [418] */ MatcherIndex(23), - /* [419] */ MatcherIndex(32), - /* [420] */ MatcherIndex(35), - /* [421] */ MatcherIndex(30), - /* [422] */ MatcherIndex(2), - /* [423] */ MatcherIndex(3), - /* [424] */ MatcherIndex(4), - /* [425] */ MatcherIndex(35), - /* [426] */ MatcherIndex(8), - /* [427] */ MatcherIndex(23), - /* [428] */ MatcherIndex(31), - /* [429] */ MatcherIndex(35), - /* [430] */ MatcherIndex(29), - /* [431] */ MatcherIndex(38), - /* [432] */ MatcherIndex(1), - /* [433] */ MatcherIndex(2), - /* [434] */ MatcherIndex(35), - /* [435] */ MatcherIndex(8), - /* [436] */ MatcherIndex(23), - /* [437] */ MatcherIndex(31), - /* [438] */ MatcherIndex(34), - /* [439] */ MatcherIndex(29), - /* [440] */ MatcherIndex(38), - /* [441] */ MatcherIndex(1), - /* [442] */ MatcherIndex(2), - /* [443] */ MatcherIndex(35), - /* [444] */ MatcherIndex(8), - /* [445] */ MatcherIndex(25), - /* [446] */ MatcherIndex(31), - /* [447] */ MatcherIndex(35), - /* [448] */ MatcherIndex(29), - /* [449] */ MatcherIndex(38), - /* [450] */ MatcherIndex(1), - /* [451] */ MatcherIndex(2), - /* [452] */ MatcherIndex(35), - /* [453] */ MatcherIndex(8), - /* [454] */ MatcherIndex(25), - /* [455] */ MatcherIndex(31), - /* [456] */ MatcherIndex(34), - /* [457] */ MatcherIndex(29), - /* [458] */ MatcherIndex(38), - /* [459] */ MatcherIndex(1), - /* [460] */ MatcherIndex(2), - /* [461] */ MatcherIndex(35), - /* [462] */ MatcherIndex(8), - /* [463] */ MatcherIndex(23), - /* [464] */ MatcherIndex(31), - /* [465] */ MatcherIndex(35), - /* [466] */ MatcherIndex(30), - /* [467] */ MatcherIndex(1), - /* [468] */ MatcherIndex(2), - /* [469] */ MatcherIndex(3), - /* [470] */ MatcherIndex(35), - /* [471] */ MatcherIndex(1), - /* [472] */ MatcherIndex(22), - /* [473] */ MatcherIndex(32), - /* [474] */ MatcherIndex(35), - /* [475] */ MatcherIndex(29), - /* [476] */ MatcherIndex(3), - /* [477] */ MatcherIndex(4), - /* [478] */ MatcherIndex(5), - /* [479] */ MatcherIndex(35), - /* [480] */ MatcherIndex(1), - /* [481] */ MatcherIndex(26), - /* [482] */ MatcherIndex(32), - /* [483] */ MatcherIndex(35), - /* [484] */ MatcherIndex(29), - /* [485] */ MatcherIndex(3), - /* [486] */ MatcherIndex(4), - /* [487] */ MatcherIndex(5), - /* [488] */ MatcherIndex(35), - /* [489] */ MatcherIndex(1), - /* [490] */ MatcherIndex(23), - /* [491] */ MatcherIndex(32), - /* [492] */ MatcherIndex(35), - /* [493] */ MatcherIndex(29), - /* [494] */ MatcherIndex(3), - /* [495] */ MatcherIndex(4), - /* [496] */ MatcherIndex(5), - /* [497] */ MatcherIndex(35), - /* [498] */ MatcherIndex(1), - /* [499] */ MatcherIndex(23), - /* [500] */ MatcherIndex(32), - /* [501] */ MatcherIndex(34), - /* [502] */ MatcherIndex(29), - /* [503] */ MatcherIndex(3), - /* [504] */ MatcherIndex(4), - /* [505] */ MatcherIndex(5), - /* [506] */ MatcherIndex(35), - /* [507] */ MatcherIndex(1), - /* [508] */ MatcherIndex(24), - /* [509] */ MatcherIndex(32), - /* [510] */ MatcherIndex(35), - /* [511] */ MatcherIndex(29), - /* [512] */ MatcherIndex(3), - /* [513] */ MatcherIndex(4), - /* [514] */ MatcherIndex(5), - /* [515] */ MatcherIndex(35), - /* [516] */ MatcherIndex(1), - /* [517] */ MatcherIndex(25), - /* [518] */ MatcherIndex(32), - /* [519] */ MatcherIndex(35), - /* [520] */ MatcherIndex(29), - /* [521] */ MatcherIndex(3), - /* [522] */ MatcherIndex(4), - /* [523] */ MatcherIndex(5), - /* [524] */ MatcherIndex(35), - /* [525] */ MatcherIndex(1), - /* [526] */ MatcherIndex(25), - /* [527] */ MatcherIndex(32), - /* [528] */ MatcherIndex(34), - /* [529] */ MatcherIndex(29), - /* [530] */ MatcherIndex(3), - /* [531] */ MatcherIndex(4), - /* [532] */ MatcherIndex(5), - /* [533] */ MatcherIndex(35), - /* [534] */ MatcherIndex(8), - /* [535] */ MatcherIndex(23), - /* [536] */ MatcherIndex(31), - /* [537] */ MatcherIndex(35), - /* [538] */ MatcherIndex(29), - /* [539] */ MatcherIndex(2), - /* [540] */ MatcherIndex(3), - /* [541] */ MatcherIndex(4), - /* [542] */ MatcherIndex(35), - /* [543] */ MatcherIndex(8), - /* [544] */ MatcherIndex(23), - /* [545] */ MatcherIndex(31), - /* [546] */ MatcherIndex(34), - /* [547] */ MatcherIndex(29), - /* [548] */ MatcherIndex(2), - /* [549] */ MatcherIndex(3), - /* [550] */ MatcherIndex(4), - /* [551] */ MatcherIndex(35), - /* [552] */ MatcherIndex(8), - /* [553] */ MatcherIndex(25), - /* [554] */ MatcherIndex(31), - /* [555] */ MatcherIndex(35), - /* [556] */ MatcherIndex(29), - /* [557] */ MatcherIndex(2), - /* [558] */ MatcherIndex(3), - /* [559] */ MatcherIndex(4), - /* [560] */ MatcherIndex(35), - /* [561] */ MatcherIndex(8), - /* [562] */ MatcherIndex(25), - /* [563] */ MatcherIndex(31), - /* [564] */ MatcherIndex(34), - /* [565] */ MatcherIndex(29), - /* [566] */ MatcherIndex(2), - /* [567] */ MatcherIndex(3), - /* [568] */ MatcherIndex(4), - /* [569] */ MatcherIndex(35), - /* [570] */ MatcherIndex(1), - /* [571] */ MatcherIndex(28), - /* [572] */ MatcherIndex(2), - /* [573] */ MatcherIndex(3), - /* [574] */ MatcherIndex(29), - /* [575] */ MatcherIndex(4), - /* [576] */ MatcherIndex(5), - /* [577] */ MatcherIndex(6), - /* [578] */ MatcherIndex(35), - /* [579] */ MatcherIndex(1), - /* [580] */ MatcherIndex(23), - /* [581] */ MatcherIndex(2), - /* [582] */ MatcherIndex(3), - /* [583] */ MatcherIndex(30), - /* [584] */ MatcherIndex(4), - /* [585] */ MatcherIndex(5), - /* [586] */ MatcherIndex(6), - /* [587] */ MatcherIndex(35), - /* [588] */ MatcherIndex(8), - /* [589] */ MatcherIndex(22), - /* [590] */ MatcherIndex(32), - /* [591] */ MatcherIndex(35), - /* [592] */ MatcherIndex(29), - /* [593] */ MatcherIndex(38), - /* [594] */ MatcherIndex(0), - /* [595] */ MatcherIndex(1), - /* [596] */ MatcherIndex(35), - /* [597] */ MatcherIndex(8), - /* [598] */ MatcherIndex(26), - /* [599] */ MatcherIndex(32), - /* [600] */ MatcherIndex(35), - /* [601] */ MatcherIndex(29), - /* [602] */ MatcherIndex(38), - /* [603] */ MatcherIndex(0), - /* [604] */ MatcherIndex(1), - /* [605] */ MatcherIndex(35), - /* [606] */ MatcherIndex(10), - /* [607] */ MatcherIndex(22), - /* [608] */ MatcherIndex(32), - /* [609] */ MatcherIndex(35), - /* [610] */ MatcherIndex(29), - /* [611] */ MatcherIndex(38), - /* [612] */ MatcherIndex(0), - /* [613] */ MatcherIndex(1), - /* [614] */ MatcherIndex(35), - /* [615] */ MatcherIndex(10), - /* [616] */ MatcherIndex(26), - /* [617] */ MatcherIndex(32), - /* [618] */ MatcherIndex(35), - /* [619] */ MatcherIndex(29), - /* [620] */ MatcherIndex(38), - /* [621] */ MatcherIndex(0), - /* [622] */ MatcherIndex(1), - /* [623] */ MatcherIndex(35), - /* [624] */ MatcherIndex(11), - /* [625] */ MatcherIndex(22), - /* [626] */ MatcherIndex(32), - /* [627] */ MatcherIndex(35), - /* [628] */ MatcherIndex(29), - /* [629] */ MatcherIndex(38), - /* [630] */ MatcherIndex(0), - /* [631] */ MatcherIndex(1), - /* [632] */ MatcherIndex(35), - /* [633] */ MatcherIndex(11), - /* [634] */ MatcherIndex(26), - /* [635] */ MatcherIndex(32), - /* [636] */ MatcherIndex(35), - /* [637] */ MatcherIndex(29), - /* [638] */ MatcherIndex(38), - /* [639] */ MatcherIndex(0), - /* [640] */ MatcherIndex(1), - /* [641] */ MatcherIndex(35), - /* [642] */ MatcherIndex(8), - /* [643] */ MatcherIndex(23), - /* [644] */ MatcherIndex(32), - /* [645] */ MatcherIndex(35), - /* [646] */ MatcherIndex(29), - /* [647] */ MatcherIndex(38), - /* [648] */ MatcherIndex(0), - /* [649] */ MatcherIndex(1), - /* [650] */ MatcherIndex(35), - /* [651] */ MatcherIndex(10), - /* [652] */ MatcherIndex(23), - /* [653] */ MatcherIndex(32), - /* [654] */ MatcherIndex(35), - /* [655] */ MatcherIndex(29), - /* [656] */ MatcherIndex(38), - /* [657] */ MatcherIndex(0), - /* [658] */ MatcherIndex(1), - /* [659] */ MatcherIndex(35), - /* [660] */ MatcherIndex(11), - /* [661] */ MatcherIndex(23), - /* [662] */ MatcherIndex(32), - /* [663] */ MatcherIndex(35), - /* [664] */ MatcherIndex(29), - /* [665] */ MatcherIndex(38), - /* [666] */ MatcherIndex(0), - /* [667] */ MatcherIndex(1), - /* [668] */ MatcherIndex(35), - /* [669] */ MatcherIndex(8), - /* [670] */ MatcherIndex(23), - /* [671] */ MatcherIndex(32), - /* [672] */ MatcherIndex(34), - /* [673] */ MatcherIndex(29), - /* [674] */ MatcherIndex(38), - /* [675] */ MatcherIndex(0), - /* [676] */ MatcherIndex(1), - /* [677] */ MatcherIndex(35), - /* [678] */ MatcherIndex(10), - /* [679] */ MatcherIndex(23), - /* [680] */ MatcherIndex(32), - /* [681] */ MatcherIndex(34), - /* [682] */ MatcherIndex(29), - /* [683] */ MatcherIndex(38), - /* [684] */ MatcherIndex(0), - /* [685] */ MatcherIndex(1), - /* [686] */ MatcherIndex(35), - /* [687] */ MatcherIndex(11), - /* [688] */ MatcherIndex(23), - /* [689] */ MatcherIndex(32), - /* [690] */ MatcherIndex(34), - /* [691] */ MatcherIndex(29), - /* [692] */ MatcherIndex(38), - /* [693] */ MatcherIndex(0), - /* [694] */ MatcherIndex(1), - /* [695] */ MatcherIndex(35), - /* [696] */ MatcherIndex(8), - /* [697] */ MatcherIndex(24), - /* [698] */ MatcherIndex(32), - /* [699] */ MatcherIndex(35), - /* [700] */ MatcherIndex(29), - /* [701] */ MatcherIndex(38), - /* [702] */ MatcherIndex(0), - /* [703] */ MatcherIndex(1), - /* [704] */ MatcherIndex(35), - /* [705] */ MatcherIndex(10), - /* [706] */ MatcherIndex(24), - /* [707] */ MatcherIndex(32), - /* [708] */ MatcherIndex(35), - /* [709] */ MatcherIndex(29), - /* [710] */ MatcherIndex(38), - /* [711] */ MatcherIndex(0), - /* [712] */ MatcherIndex(1), - /* [713] */ MatcherIndex(35), - /* [714] */ MatcherIndex(11), - /* [715] */ MatcherIndex(24), - /* [716] */ MatcherIndex(32), - /* [717] */ MatcherIndex(35), - /* [718] */ MatcherIndex(29), - /* [719] */ MatcherIndex(38), - /* [720] */ MatcherIndex(0), - /* [721] */ MatcherIndex(1), - /* [722] */ MatcherIndex(35), - /* [723] */ MatcherIndex(1), - /* [724] */ MatcherIndex(27), - /* [725] */ MatcherIndex(32), - /* [726] */ MatcherIndex(35), - /* [727] */ MatcherIndex(29), - /* [728] */ MatcherIndex(38), - /* [729] */ MatcherIndex(0), - /* [730] */ MatcherIndex(3), - /* [731] */ MatcherIndex(35), - /* [732] */ MatcherIndex(8), - /* [733] */ MatcherIndex(22), - /* [734] */ MatcherIndex(32), - /* [735] */ MatcherIndex(35), - /* [736] */ MatcherIndex(29), - /* [737] */ MatcherIndex(38), - /* [738] */ MatcherIndex(16), - /* [739] */ MatcherIndex(21), - /* [740] */ MatcherIndex(35), - /* [741] */ MatcherIndex(8), - /* [742] */ MatcherIndex(26), - /* [743] */ MatcherIndex(32), - /* [744] */ MatcherIndex(35), - /* [745] */ MatcherIndex(29), - /* [746] */ MatcherIndex(38), - /* [747] */ MatcherIndex(16), - /* [748] */ MatcherIndex(21), - /* [749] */ MatcherIndex(35), - /* [750] */ MatcherIndex(10), - /* [751] */ MatcherIndex(22), - /* [752] */ MatcherIndex(32), - /* [753] */ MatcherIndex(35), - /* [754] */ MatcherIndex(29), - /* [755] */ MatcherIndex(38), - /* [756] */ MatcherIndex(17), + /* [17] */ MatcherIndex(24), + /* [18] */ MatcherIndex(32), + /* [19] */ MatcherIndex(0), + /* [20] */ MatcherIndex(15), + /* [21] */ MatcherIndex(2), + /* [22] */ MatcherIndex(38), + /* [23] */ MatcherIndex(37), + /* [24] */ MatcherIndex(8), + /* [25] */ MatcherIndex(20), + /* [26] */ MatcherIndex(28), + /* [27] */ MatcherIndex(30), + /* [28] */ MatcherIndex(24), + /* [29] */ MatcherIndex(32), + /* [30] */ MatcherIndex(0), + /* [31] */ MatcherIndex(15), + /* [32] */ MatcherIndex(1), + /* [33] */ MatcherIndex(38), + /* [34] */ MatcherIndex(37), + /* [35] */ MatcherIndex(8), + /* [36] */ MatcherIndex(20), + /* [37] */ MatcherIndex(28), + /* [38] */ MatcherIndex(29), + /* [39] */ MatcherIndex(24), + /* [40] */ MatcherIndex(32), + /* [41] */ MatcherIndex(0), + /* [42] */ MatcherIndex(15), + /* [43] */ MatcherIndex(0), + /* [44] */ MatcherIndex(38), + /* [45] */ MatcherIndex(37), + /* [46] */ MatcherIndex(0), + /* [47] */ MatcherIndex(18), + /* [48] */ MatcherIndex(27), + /* [49] */ MatcherIndex(30), + /* [50] */ MatcherIndex(24), + /* [51] */ MatcherIndex(32), + /* [52] */ MatcherIndex(2), + /* [53] */ MatcherIndex(15), + /* [54] */ MatcherIndex(3), + /* [55] */ MatcherIndex(38), + /* [56] */ MatcherIndex(37), + /* [57] */ MatcherIndex(0), + /* [58] */ MatcherIndex(18), + /* [59] */ MatcherIndex(27), + /* [60] */ MatcherIndex(30), + /* [61] */ MatcherIndex(24), + /* [62] */ MatcherIndex(32), + /* [63] */ MatcherIndex(3), + /* [64] */ MatcherIndex(15), + /* [65] */ MatcherIndex(38), + /* [66] */ MatcherIndex(37), + /* [67] */ MatcherIndex(0), + /* [68] */ MatcherIndex(18), + /* [69] */ MatcherIndex(27), + /* [70] */ MatcherIndex(29), + /* [71] */ MatcherIndex(24), + /* [72] */ MatcherIndex(32), + /* [73] */ MatcherIndex(2), + /* [74] */ MatcherIndex(15), + /* [75] */ MatcherIndex(38), + /* [76] */ MatcherIndex(37), + /* [77] */ MatcherIndex(0), + /* [78] */ MatcherIndex(18), + /* [79] */ MatcherIndex(27), + /* [80] */ MatcherIndex(29), + /* [81] */ MatcherIndex(24), + /* [82] */ MatcherIndex(32), + /* [83] */ MatcherIndex(3), + /* [84] */ MatcherIndex(15), + /* [85] */ MatcherIndex(38), + /* [86] */ MatcherIndex(37), + /* [87] */ MatcherIndex(0), + /* [88] */ MatcherIndex(20), + /* [89] */ MatcherIndex(27), + /* [90] */ MatcherIndex(30), + /* [91] */ MatcherIndex(24), + /* [92] */ MatcherIndex(32), + /* [93] */ MatcherIndex(2), + /* [94] */ MatcherIndex(15), + /* [95] */ MatcherIndex(38), + /* [96] */ MatcherIndex(37), + /* [97] */ MatcherIndex(0), + /* [98] */ MatcherIndex(20), + /* [99] */ MatcherIndex(27), + /* [100] */ MatcherIndex(29), + /* [101] */ MatcherIndex(24), + /* [102] */ MatcherIndex(32), + /* [103] */ MatcherIndex(2), + /* [104] */ MatcherIndex(15), + /* [105] */ MatcherIndex(38), + /* [106] */ MatcherIndex(37), + /* [107] */ MatcherIndex(8), + /* [108] */ MatcherIndex(18), + /* [109] */ MatcherIndex(26), + /* [110] */ MatcherIndex(30), + /* [111] */ MatcherIndex(24), + /* [112] */ MatcherIndex(32), + /* [113] */ MatcherIndex(1), + /* [114] */ MatcherIndex(15), + /* [115] */ MatcherIndex(38), + /* [116] */ MatcherIndex(37), + /* [117] */ MatcherIndex(8), + /* [118] */ MatcherIndex(18), + /* [119] */ MatcherIndex(26), + /* [120] */ MatcherIndex(30), + /* [121] */ MatcherIndex(24), + /* [122] */ MatcherIndex(32), + /* [123] */ MatcherIndex(2), + /* [124] */ MatcherIndex(15), + /* [125] */ MatcherIndex(38), + /* [126] */ MatcherIndex(37), + /* [127] */ MatcherIndex(8), + /* [128] */ MatcherIndex(18), + /* [129] */ MatcherIndex(26), + /* [130] */ MatcherIndex(29), + /* [131] */ MatcherIndex(24), + /* [132] */ MatcherIndex(32), + /* [133] */ MatcherIndex(1), + /* [134] */ MatcherIndex(15), + /* [135] */ MatcherIndex(38), + /* [136] */ MatcherIndex(37), + /* [137] */ MatcherIndex(8), + /* [138] */ MatcherIndex(18), + /* [139] */ MatcherIndex(26), + /* [140] */ MatcherIndex(29), + /* [141] */ MatcherIndex(24), + /* [142] */ MatcherIndex(32), + /* [143] */ MatcherIndex(2), + /* [144] */ MatcherIndex(15), + /* [145] */ MatcherIndex(38), + /* [146] */ MatcherIndex(37), + /* [147] */ MatcherIndex(8), + /* [148] */ MatcherIndex(20), + /* [149] */ MatcherIndex(26), + /* [150] */ MatcherIndex(30), + /* [151] */ MatcherIndex(24), + /* [152] */ MatcherIndex(32), + /* [153] */ MatcherIndex(1), + /* [154] */ MatcherIndex(15), + /* [155] */ MatcherIndex(38), + /* [156] */ MatcherIndex(37), + /* [157] */ MatcherIndex(8), + /* [158] */ MatcherIndex(20), + /* [159] */ MatcherIndex(26), + /* [160] */ MatcherIndex(29), + /* [161] */ MatcherIndex(24), + /* [162] */ MatcherIndex(32), + /* [163] */ MatcherIndex(1), + /* [164] */ MatcherIndex(15), + /* [165] */ MatcherIndex(38), + /* [166] */ MatcherIndex(37), + /* [167] */ MatcherIndex(0), + /* [168] */ MatcherIndex(17), + /* [169] */ MatcherIndex(27), + /* [170] */ MatcherIndex(30), + /* [171] */ MatcherIndex(24), + /* [172] */ MatcherIndex(32), + /* [173] */ MatcherIndex(1), + /* [174] */ MatcherIndex(15), + /* [175] */ MatcherIndex(38), + /* [176] */ MatcherIndex(37), + /* [177] */ MatcherIndex(0), + /* [178] */ MatcherIndex(18), + /* [179] */ MatcherIndex(27), + /* [180] */ MatcherIndex(30), + /* [181] */ MatcherIndex(24), + /* [182] */ MatcherIndex(32), + /* [183] */ MatcherIndex(1), + /* [184] */ MatcherIndex(15), + /* [185] */ MatcherIndex(38), + /* [186] */ MatcherIndex(37), + /* [187] */ MatcherIndex(0), + /* [188] */ MatcherIndex(18), + /* [189] */ MatcherIndex(27), + /* [190] */ MatcherIndex(29), + /* [191] */ MatcherIndex(24), + /* [192] */ MatcherIndex(32), + /* [193] */ MatcherIndex(1), + /* [194] */ MatcherIndex(15), + /* [195] */ MatcherIndex(38), + /* [196] */ MatcherIndex(37), + /* [197] */ MatcherIndex(0), + /* [198] */ MatcherIndex(19), + /* [199] */ MatcherIndex(27), + /* [200] */ MatcherIndex(30), + /* [201] */ MatcherIndex(24), + /* [202] */ MatcherIndex(32), + /* [203] */ MatcherIndex(1), + /* [204] */ MatcherIndex(15), + /* [205] */ MatcherIndex(38), + /* [206] */ MatcherIndex(37), + /* [207] */ MatcherIndex(0), + /* [208] */ MatcherIndex(19), + /* [209] */ MatcherIndex(27), + /* [210] */ MatcherIndex(30), + /* [211] */ MatcherIndex(24), + /* [212] */ MatcherIndex(32), + /* [213] */ MatcherIndex(2), + /* [214] */ MatcherIndex(15), + /* [215] */ MatcherIndex(38), + /* [216] */ MatcherIndex(37), + /* [217] */ MatcherIndex(0), + /* [218] */ MatcherIndex(20), + /* [219] */ MatcherIndex(27), + /* [220] */ MatcherIndex(30), + /* [221] */ MatcherIndex(24), + /* [222] */ MatcherIndex(32), + /* [223] */ MatcherIndex(1), + /* [224] */ MatcherIndex(15), + /* [225] */ MatcherIndex(38), + /* [226] */ MatcherIndex(37), + /* [227] */ MatcherIndex(0), + /* [228] */ MatcherIndex(20), + /* [229] */ MatcherIndex(27), + /* [230] */ MatcherIndex(29), + /* [231] */ MatcherIndex(24), + /* [232] */ MatcherIndex(32), + /* [233] */ MatcherIndex(1), + /* [234] */ MatcherIndex(15), + /* [235] */ MatcherIndex(38), + /* [236] */ MatcherIndex(37), + /* [237] */ MatcherIndex(8), + /* [238] */ MatcherIndex(18), + /* [239] */ MatcherIndex(26), + /* [240] */ MatcherIndex(30), + /* [241] */ MatcherIndex(24), + /* [242] */ MatcherIndex(32), + /* [243] */ MatcherIndex(0), + /* [244] */ MatcherIndex(15), + /* [245] */ MatcherIndex(38), + /* [246] */ MatcherIndex(37), + /* [247] */ MatcherIndex(8), + /* [248] */ MatcherIndex(20), + /* [249] */ MatcherIndex(26), + /* [250] */ MatcherIndex(30), + /* [251] */ MatcherIndex(24), + /* [252] */ MatcherIndex(32), + /* [253] */ MatcherIndex(0), + /* [254] */ MatcherIndex(15), + /* [255] */ MatcherIndex(38), + /* [256] */ MatcherIndex(37), + /* [257] */ MatcherIndex(8), + /* [258] */ MatcherIndex(18), + /* [259] */ MatcherIndex(26), + /* [260] */ MatcherIndex(29), + /* [261] */ MatcherIndex(24), + /* [262] */ MatcherIndex(32), + /* [263] */ MatcherIndex(0), + /* [264] */ MatcherIndex(15), + /* [265] */ MatcherIndex(38), + /* [266] */ MatcherIndex(37), + /* [267] */ MatcherIndex(8), + /* [268] */ MatcherIndex(20), + /* [269] */ MatcherIndex(26), + /* [270] */ MatcherIndex(29), + /* [271] */ MatcherIndex(24), + /* [272] */ MatcherIndex(32), + /* [273] */ MatcherIndex(0), + /* [274] */ MatcherIndex(15), + /* [275] */ MatcherIndex(38), + /* [276] */ MatcherIndex(37), + /* [277] */ MatcherIndex(8), + /* [278] */ MatcherIndex(18), + /* [279] */ MatcherIndex(28), + /* [280] */ MatcherIndex(30), + /* [281] */ MatcherIndex(24), + /* [282] */ MatcherIndex(32), + /* [283] */ MatcherIndex(1), + /* [284] */ MatcherIndex(15), + /* [285] */ MatcherIndex(38), + /* [286] */ MatcherIndex(37), + /* [287] */ MatcherIndex(8), + /* [288] */ MatcherIndex(18), + /* [289] */ MatcherIndex(28), + /* [290] */ MatcherIndex(29), + /* [291] */ MatcherIndex(24), + /* [292] */ MatcherIndex(32), + /* [293] */ MatcherIndex(1), + /* [294] */ MatcherIndex(15), + /* [295] */ MatcherIndex(37), + /* [296] */ MatcherIndex(0), + /* [297] */ MatcherIndex(17), + /* [298] */ MatcherIndex(27), + /* [299] */ MatcherIndex(30), + /* [300] */ MatcherIndex(24), + /* [301] */ MatcherIndex(32), + /* [302] */ MatcherIndex(2), + /* [303] */ MatcherIndex(15), + /* [304] */ MatcherIndex(37), + /* [305] */ MatcherIndex(0), + /* [306] */ MatcherIndex(18), + /* [307] */ MatcherIndex(27), + /* [308] */ MatcherIndex(30), + /* [309] */ MatcherIndex(25), + /* [310] */ MatcherIndex(32), + /* [311] */ MatcherIndex(2), + /* [312] */ MatcherIndex(15), + /* [313] */ MatcherIndex(37), + /* [314] */ MatcherIndex(8), + /* [315] */ MatcherIndex(18), + /* [316] */ MatcherIndex(26), + /* [317] */ MatcherIndex(30), + /* [318] */ MatcherIndex(25), + /* [319] */ MatcherIndex(32), + /* [320] */ MatcherIndex(1), + /* [321] */ MatcherIndex(15), + /* [322] */ MatcherIndex(37), + /* [323] */ MatcherIndex(0), + /* [324] */ MatcherIndex(17), + /* [325] */ MatcherIndex(27), + /* [326] */ MatcherIndex(30), + /* [327] */ MatcherIndex(24), + /* [328] */ MatcherIndex(32), + /* [329] */ MatcherIndex(3), + /* [330] */ MatcherIndex(15), + /* [331] */ MatcherIndex(37), + /* [332] */ MatcherIndex(0), + /* [333] */ MatcherIndex(19), + /* [334] */ MatcherIndex(27), + /* [335] */ MatcherIndex(30), + /* [336] */ MatcherIndex(24), + /* [337] */ MatcherIndex(32), + /* [338] */ MatcherIndex(3), + /* [339] */ MatcherIndex(15), + /* [340] */ MatcherIndex(37), + /* [341] */ MatcherIndex(0), + /* [342] */ MatcherIndex(18), + /* [343] */ MatcherIndex(27), + /* [344] */ MatcherIndex(30), + /* [345] */ MatcherIndex(25), + /* [346] */ MatcherIndex(32), + /* [347] */ MatcherIndex(3), + /* [348] */ MatcherIndex(15), + /* [349] */ MatcherIndex(37), + /* [350] */ MatcherIndex(8), + /* [351] */ MatcherIndex(18), + /* [352] */ MatcherIndex(26), + /* [353] */ MatcherIndex(30), + /* [354] */ MatcherIndex(25), + /* [355] */ MatcherIndex(32), + /* [356] */ MatcherIndex(2), + /* [357] */ MatcherIndex(15), + /* [358] */ MatcherIndex(37), + /* [359] */ MatcherIndex(1), + /* [360] */ MatcherIndex(17), + /* [361] */ MatcherIndex(27), + /* [362] */ MatcherIndex(30), + /* [363] */ MatcherIndex(24), + /* [364] */ MatcherIndex(33), + /* [365] */ MatcherIndex(2), + /* [366] */ MatcherIndex(3), + /* [367] */ MatcherIndex(37), + /* [368] */ MatcherIndex(1), + /* [369] */ MatcherIndex(21), + /* [370] */ MatcherIndex(27), + /* [371] */ MatcherIndex(30), + /* [372] */ MatcherIndex(24), + /* [373] */ MatcherIndex(33), + /* [374] */ MatcherIndex(2), + /* [375] */ MatcherIndex(3), + /* [376] */ MatcherIndex(37), + /* [377] */ MatcherIndex(1), + /* [378] */ MatcherIndex(18), + /* [379] */ MatcherIndex(27), + /* [380] */ MatcherIndex(30), + /* [381] */ MatcherIndex(24), + /* [382] */ MatcherIndex(33), + /* [383] */ MatcherIndex(2), + /* [384] */ MatcherIndex(3), + /* [385] */ MatcherIndex(37), + /* [386] */ MatcherIndex(1), + /* [387] */ MatcherIndex(18), + /* [388] */ MatcherIndex(27), + /* [389] */ MatcherIndex(29), + /* [390] */ MatcherIndex(24), + /* [391] */ MatcherIndex(33), + /* [392] */ MatcherIndex(2), + /* [393] */ MatcherIndex(3), + /* [394] */ MatcherIndex(37), + /* [395] */ MatcherIndex(1), + /* [396] */ MatcherIndex(19), + /* [397] */ MatcherIndex(27), + /* [398] */ MatcherIndex(30), + /* [399] */ MatcherIndex(24), + /* [400] */ MatcherIndex(33), + /* [401] */ MatcherIndex(2), + /* [402] */ MatcherIndex(3), + /* [403] */ MatcherIndex(37), + /* [404] */ MatcherIndex(1), + /* [405] */ MatcherIndex(20), + /* [406] */ MatcherIndex(27), + /* [407] */ MatcherIndex(30), + /* [408] */ MatcherIndex(24), + /* [409] */ MatcherIndex(33), + /* [410] */ MatcherIndex(2), + /* [411] */ MatcherIndex(3), + /* [412] */ MatcherIndex(37), + /* [413] */ MatcherIndex(1), + /* [414] */ MatcherIndex(20), + /* [415] */ MatcherIndex(27), + /* [416] */ MatcherIndex(29), + /* [417] */ MatcherIndex(24), + /* [418] */ MatcherIndex(33), + /* [419] */ MatcherIndex(2), + /* [420] */ MatcherIndex(3), + /* [421] */ MatcherIndex(37), + /* [422] */ MatcherIndex(1), + /* [423] */ MatcherIndex(18), + /* [424] */ MatcherIndex(27), + /* [425] */ MatcherIndex(30), + /* [426] */ MatcherIndex(25), + /* [427] */ MatcherIndex(2), + /* [428] */ MatcherIndex(3), + /* [429] */ MatcherIndex(4), + /* [430] */ MatcherIndex(37), + /* [431] */ MatcherIndex(8), + /* [432] */ MatcherIndex(18), + /* [433] */ MatcherIndex(26), + /* [434] */ MatcherIndex(30), + /* [435] */ MatcherIndex(24), + /* [436] */ MatcherIndex(33), + /* [437] */ MatcherIndex(1), + /* [438] */ MatcherIndex(2), + /* [439] */ MatcherIndex(37), + /* [440] */ MatcherIndex(8), + /* [441] */ MatcherIndex(18), + /* [442] */ MatcherIndex(26), + /* [443] */ MatcherIndex(29), + /* [444] */ MatcherIndex(24), + /* [445] */ MatcherIndex(33), + /* [446] */ MatcherIndex(1), + /* [447] */ MatcherIndex(2), + /* [448] */ MatcherIndex(37), + /* [449] */ MatcherIndex(8), + /* [450] */ MatcherIndex(20), + /* [451] */ MatcherIndex(26), + /* [452] */ MatcherIndex(30), + /* [453] */ MatcherIndex(24), + /* [454] */ MatcherIndex(33), + /* [455] */ MatcherIndex(1), + /* [456] */ MatcherIndex(2), + /* [457] */ MatcherIndex(37), + /* [458] */ MatcherIndex(8), + /* [459] */ MatcherIndex(20), + /* [460] */ MatcherIndex(26), + /* [461] */ MatcherIndex(29), + /* [462] */ MatcherIndex(24), + /* [463] */ MatcherIndex(33), + /* [464] */ MatcherIndex(1), + /* [465] */ MatcherIndex(2), + /* [466] */ MatcherIndex(37), + /* [467] */ MatcherIndex(8), + /* [468] */ MatcherIndex(18), + /* [469] */ MatcherIndex(26), + /* [470] */ MatcherIndex(30), + /* [471] */ MatcherIndex(25), + /* [472] */ MatcherIndex(1), + /* [473] */ MatcherIndex(2), + /* [474] */ MatcherIndex(3), + /* [475] */ MatcherIndex(37), + /* [476] */ MatcherIndex(1), + /* [477] */ MatcherIndex(17), + /* [478] */ MatcherIndex(27), + /* [479] */ MatcherIndex(30), + /* [480] */ MatcherIndex(24), + /* [481] */ MatcherIndex(3), + /* [482] */ MatcherIndex(4), + /* [483] */ MatcherIndex(5), + /* [484] */ MatcherIndex(37), + /* [485] */ MatcherIndex(1), + /* [486] */ MatcherIndex(21), + /* [487] */ MatcherIndex(27), + /* [488] */ MatcherIndex(30), + /* [489] */ MatcherIndex(24), + /* [490] */ MatcherIndex(3), + /* [491] */ MatcherIndex(4), + /* [492] */ MatcherIndex(5), + /* [493] */ MatcherIndex(37), + /* [494] */ MatcherIndex(1), + /* [495] */ MatcherIndex(18), + /* [496] */ MatcherIndex(27), + /* [497] */ MatcherIndex(30), + /* [498] */ MatcherIndex(24), + /* [499] */ MatcherIndex(3), + /* [500] */ MatcherIndex(4), + /* [501] */ MatcherIndex(5), + /* [502] */ MatcherIndex(37), + /* [503] */ MatcherIndex(1), + /* [504] */ MatcherIndex(18), + /* [505] */ MatcherIndex(27), + /* [506] */ MatcherIndex(29), + /* [507] */ MatcherIndex(24), + /* [508] */ MatcherIndex(3), + /* [509] */ MatcherIndex(4), + /* [510] */ MatcherIndex(5), + /* [511] */ MatcherIndex(37), + /* [512] */ MatcherIndex(1), + /* [513] */ MatcherIndex(19), + /* [514] */ MatcherIndex(27), + /* [515] */ MatcherIndex(30), + /* [516] */ MatcherIndex(24), + /* [517] */ MatcherIndex(3), + /* [518] */ MatcherIndex(4), + /* [519] */ MatcherIndex(5), + /* [520] */ MatcherIndex(37), + /* [521] */ MatcherIndex(1), + /* [522] */ MatcherIndex(20), + /* [523] */ MatcherIndex(27), + /* [524] */ MatcherIndex(30), + /* [525] */ MatcherIndex(24), + /* [526] */ MatcherIndex(3), + /* [527] */ MatcherIndex(4), + /* [528] */ MatcherIndex(5), + /* [529] */ MatcherIndex(37), + /* [530] */ MatcherIndex(1), + /* [531] */ MatcherIndex(20), + /* [532] */ MatcherIndex(27), + /* [533] */ MatcherIndex(29), + /* [534] */ MatcherIndex(24), + /* [535] */ MatcherIndex(3), + /* [536] */ MatcherIndex(4), + /* [537] */ MatcherIndex(5), + /* [538] */ MatcherIndex(37), + /* [539] */ MatcherIndex(8), + /* [540] */ MatcherIndex(18), + /* [541] */ MatcherIndex(26), + /* [542] */ MatcherIndex(30), + /* [543] */ MatcherIndex(24), + /* [544] */ MatcherIndex(2), + /* [545] */ MatcherIndex(3), + /* [546] */ MatcherIndex(4), + /* [547] */ MatcherIndex(37), + /* [548] */ MatcherIndex(8), + /* [549] */ MatcherIndex(18), + /* [550] */ MatcherIndex(26), + /* [551] */ MatcherIndex(29), + /* [552] */ MatcherIndex(24), + /* [553] */ MatcherIndex(2), + /* [554] */ MatcherIndex(3), + /* [555] */ MatcherIndex(4), + /* [556] */ MatcherIndex(37), + /* [557] */ MatcherIndex(8), + /* [558] */ MatcherIndex(20), + /* [559] */ MatcherIndex(26), + /* [560] */ MatcherIndex(30), + /* [561] */ MatcherIndex(24), + /* [562] */ MatcherIndex(2), + /* [563] */ MatcherIndex(3), + /* [564] */ MatcherIndex(4), + /* [565] */ MatcherIndex(37), + /* [566] */ MatcherIndex(8), + /* [567] */ MatcherIndex(20), + /* [568] */ MatcherIndex(26), + /* [569] */ MatcherIndex(29), + /* [570] */ MatcherIndex(24), + /* [571] */ MatcherIndex(2), + /* [572] */ MatcherIndex(3), + /* [573] */ MatcherIndex(4), + /* [574] */ MatcherIndex(37), + /* [575] */ MatcherIndex(1), + /* [576] */ MatcherIndex(23), + /* [577] */ MatcherIndex(2), + /* [578] */ MatcherIndex(3), + /* [579] */ MatcherIndex(24), + /* [580] */ MatcherIndex(4), + /* [581] */ MatcherIndex(5), + /* [582] */ MatcherIndex(6), + /* [583] */ MatcherIndex(37), + /* [584] */ MatcherIndex(1), + /* [585] */ MatcherIndex(18), + /* [586] */ MatcherIndex(2), + /* [587] */ MatcherIndex(3), + /* [588] */ MatcherIndex(25), + /* [589] */ MatcherIndex(4), + /* [590] */ MatcherIndex(5), + /* [591] */ MatcherIndex(6), + /* [592] */ MatcherIndex(37), + /* [593] */ MatcherIndex(8), + /* [594] */ MatcherIndex(17), + /* [595] */ MatcherIndex(27), + /* [596] */ MatcherIndex(30), + /* [597] */ MatcherIndex(24), + /* [598] */ MatcherIndex(33), + /* [599] */ MatcherIndex(0), + /* [600] */ MatcherIndex(1), + /* [601] */ MatcherIndex(37), + /* [602] */ MatcherIndex(8), + /* [603] */ MatcherIndex(21), + /* [604] */ MatcherIndex(27), + /* [605] */ MatcherIndex(30), + /* [606] */ MatcherIndex(24), + /* [607] */ MatcherIndex(33), + /* [608] */ MatcherIndex(0), + /* [609] */ MatcherIndex(1), + /* [610] */ MatcherIndex(37), + /* [611] */ MatcherIndex(10), + /* [612] */ MatcherIndex(17), + /* [613] */ MatcherIndex(27), + /* [614] */ MatcherIndex(30), + /* [615] */ MatcherIndex(24), + /* [616] */ MatcherIndex(33), + /* [617] */ MatcherIndex(0), + /* [618] */ MatcherIndex(1), + /* [619] */ MatcherIndex(37), + /* [620] */ MatcherIndex(10), + /* [621] */ MatcherIndex(21), + /* [622] */ MatcherIndex(27), + /* [623] */ MatcherIndex(30), + /* [624] */ MatcherIndex(24), + /* [625] */ MatcherIndex(33), + /* [626] */ MatcherIndex(0), + /* [627] */ MatcherIndex(1), + /* [628] */ MatcherIndex(37), + /* [629] */ MatcherIndex(11), + /* [630] */ MatcherIndex(17), + /* [631] */ MatcherIndex(27), + /* [632] */ MatcherIndex(30), + /* [633] */ MatcherIndex(24), + /* [634] */ MatcherIndex(33), + /* [635] */ MatcherIndex(0), + /* [636] */ MatcherIndex(1), + /* [637] */ MatcherIndex(37), + /* [638] */ MatcherIndex(11), + /* [639] */ MatcherIndex(21), + /* [640] */ MatcherIndex(27), + /* [641] */ MatcherIndex(30), + /* [642] */ MatcherIndex(24), + /* [643] */ MatcherIndex(33), + /* [644] */ MatcherIndex(0), + /* [645] */ MatcherIndex(1), + /* [646] */ MatcherIndex(37), + /* [647] */ MatcherIndex(8), + /* [648] */ MatcherIndex(18), + /* [649] */ MatcherIndex(27), + /* [650] */ MatcherIndex(30), + /* [651] */ MatcherIndex(24), + /* [652] */ MatcherIndex(33), + /* [653] */ MatcherIndex(0), + /* [654] */ MatcherIndex(1), + /* [655] */ MatcherIndex(37), + /* [656] */ MatcherIndex(10), + /* [657] */ MatcherIndex(18), + /* [658] */ MatcherIndex(27), + /* [659] */ MatcherIndex(30), + /* [660] */ MatcherIndex(24), + /* [661] */ MatcherIndex(33), + /* [662] */ MatcherIndex(0), + /* [663] */ MatcherIndex(1), + /* [664] */ MatcherIndex(37), + /* [665] */ MatcherIndex(11), + /* [666] */ MatcherIndex(18), + /* [667] */ MatcherIndex(27), + /* [668] */ MatcherIndex(30), + /* [669] */ MatcherIndex(24), + /* [670] */ MatcherIndex(33), + /* [671] */ MatcherIndex(0), + /* [672] */ MatcherIndex(1), + /* [673] */ MatcherIndex(37), + /* [674] */ MatcherIndex(8), + /* [675] */ MatcherIndex(18), + /* [676] */ MatcherIndex(27), + /* [677] */ MatcherIndex(29), + /* [678] */ MatcherIndex(24), + /* [679] */ MatcherIndex(33), + /* [680] */ MatcherIndex(0), + /* [681] */ MatcherIndex(1), + /* [682] */ MatcherIndex(37), + /* [683] */ MatcherIndex(10), + /* [684] */ MatcherIndex(18), + /* [685] */ MatcherIndex(27), + /* [686] */ MatcherIndex(29), + /* [687] */ MatcherIndex(24), + /* [688] */ MatcherIndex(33), + /* [689] */ MatcherIndex(0), + /* [690] */ MatcherIndex(1), + /* [691] */ MatcherIndex(37), + /* [692] */ MatcherIndex(11), + /* [693] */ MatcherIndex(18), + /* [694] */ MatcherIndex(27), + /* [695] */ MatcherIndex(29), + /* [696] */ MatcherIndex(24), + /* [697] */ MatcherIndex(33), + /* [698] */ MatcherIndex(0), + /* [699] */ MatcherIndex(1), + /* [700] */ MatcherIndex(37), + /* [701] */ MatcherIndex(8), + /* [702] */ MatcherIndex(19), + /* [703] */ MatcherIndex(27), + /* [704] */ MatcherIndex(30), + /* [705] */ MatcherIndex(24), + /* [706] */ MatcherIndex(33), + /* [707] */ MatcherIndex(0), + /* [708] */ MatcherIndex(1), + /* [709] */ MatcherIndex(37), + /* [710] */ MatcherIndex(10), + /* [711] */ MatcherIndex(19), + /* [712] */ MatcherIndex(27), + /* [713] */ MatcherIndex(30), + /* [714] */ MatcherIndex(24), + /* [715] */ MatcherIndex(33), + /* [716] */ MatcherIndex(0), + /* [717] */ MatcherIndex(1), + /* [718] */ MatcherIndex(37), + /* [719] */ MatcherIndex(11), + /* [720] */ MatcherIndex(19), + /* [721] */ MatcherIndex(27), + /* [722] */ MatcherIndex(30), + /* [723] */ MatcherIndex(24), + /* [724] */ MatcherIndex(33), + /* [725] */ MatcherIndex(0), + /* [726] */ MatcherIndex(1), + /* [727] */ MatcherIndex(37), + /* [728] */ MatcherIndex(1), + /* [729] */ MatcherIndex(22), + /* [730] */ MatcherIndex(27), + /* [731] */ MatcherIndex(30), + /* [732] */ MatcherIndex(24), + /* [733] */ MatcherIndex(33), + /* [734] */ MatcherIndex(0), + /* [735] */ MatcherIndex(3), + /* [736] */ MatcherIndex(37), + /* [737] */ MatcherIndex(1), + /* [738] */ MatcherIndex(22), + /* [739] */ MatcherIndex(27), + /* [740] */ MatcherIndex(30), + /* [741] */ MatcherIndex(25), + /* [742] */ MatcherIndex(33), + /* [743] */ MatcherIndex(0), + /* [744] */ MatcherIndex(4), + /* [745] */ MatcherIndex(37), + /* [746] */ MatcherIndex(8), + /* [747] */ MatcherIndex(17), + /* [748] */ MatcherIndex(27), + /* [749] */ MatcherIndex(30), + /* [750] */ MatcherIndex(24), + /* [751] */ MatcherIndex(33), + /* [752] */ MatcherIndex(11), + /* [753] */ MatcherIndex(16), + /* [754] */ MatcherIndex(8), + /* [755] */ MatcherIndex(37), + /* [756] */ MatcherIndex(8), /* [757] */ MatcherIndex(21), - /* [758] */ MatcherIndex(35), - /* [759] */ MatcherIndex(10), - /* [760] */ MatcherIndex(26), - /* [761] */ MatcherIndex(32), - /* [762] */ MatcherIndex(35), - /* [763] */ MatcherIndex(29), - /* [764] */ MatcherIndex(38), - /* [765] */ MatcherIndex(17), - /* [766] */ MatcherIndex(21), - /* [767] */ MatcherIndex(35), - /* [768] */ MatcherIndex(11), - /* [769] */ MatcherIndex(22), - /* [770] */ MatcherIndex(32), - /* [771] */ MatcherIndex(35), - /* [772] */ MatcherIndex(29), - /* [773] */ MatcherIndex(38), - /* [774] */ MatcherIndex(18), - /* [775] */ MatcherIndex(21), - /* [776] */ MatcherIndex(35), - /* [777] */ MatcherIndex(11), - /* [778] */ MatcherIndex(26), - /* [779] */ MatcherIndex(32), - /* [780] */ MatcherIndex(35), - /* [781] */ MatcherIndex(29), - /* [782] */ MatcherIndex(38), - /* [783] */ MatcherIndex(18), - /* [784] */ MatcherIndex(21), - /* [785] */ MatcherIndex(35), - /* [786] */ MatcherIndex(8), - /* [787] */ MatcherIndex(23), - /* [788] */ MatcherIndex(32), - /* [789] */ MatcherIndex(35), - /* [790] */ MatcherIndex(29), - /* [791] */ MatcherIndex(38), - /* [792] */ MatcherIndex(16), - /* [793] */ MatcherIndex(21), - /* [794] */ MatcherIndex(35), - /* [795] */ MatcherIndex(10), - /* [796] */ MatcherIndex(23), - /* [797] */ MatcherIndex(32), - /* [798] */ MatcherIndex(35), - /* [799] */ MatcherIndex(29), - /* [800] */ MatcherIndex(38), - /* [801] */ MatcherIndex(17), - /* [802] */ MatcherIndex(21), - /* [803] */ MatcherIndex(35), - /* [804] */ MatcherIndex(11), - /* [805] */ MatcherIndex(23), - /* [806] */ MatcherIndex(32), - /* [807] */ MatcherIndex(35), - /* [808] */ MatcherIndex(29), - /* [809] */ MatcherIndex(38), - /* [810] */ MatcherIndex(18), - /* [811] */ MatcherIndex(21), - /* [812] */ MatcherIndex(35), - /* [813] */ MatcherIndex(8), - /* [814] */ MatcherIndex(23), - /* [815] */ MatcherIndex(32), - /* [816] */ MatcherIndex(34), - /* [817] */ MatcherIndex(29), - /* [818] */ MatcherIndex(38), - /* [819] */ MatcherIndex(16), - /* [820] */ MatcherIndex(21), - /* [821] */ MatcherIndex(35), - /* [822] */ MatcherIndex(10), - /* [823] */ MatcherIndex(23), - /* [824] */ MatcherIndex(32), - /* [825] */ MatcherIndex(34), - /* [826] */ MatcherIndex(29), - /* [827] */ MatcherIndex(38), - /* [828] */ MatcherIndex(17), - /* [829] */ MatcherIndex(21), - /* [830] */ MatcherIndex(35), - /* [831] */ MatcherIndex(11), - /* [832] */ MatcherIndex(23), - /* [833] */ MatcherIndex(32), - /* [834] */ MatcherIndex(34), - /* [835] */ MatcherIndex(29), - /* [836] */ MatcherIndex(38), - /* [837] */ MatcherIndex(18), - /* [838] */ MatcherIndex(21), - /* [839] */ MatcherIndex(35), - /* [840] */ MatcherIndex(8), - /* [841] */ MatcherIndex(24), - /* [842] */ MatcherIndex(32), - /* [843] */ MatcherIndex(35), - /* [844] */ MatcherIndex(29), - /* [845] */ MatcherIndex(38), - /* [846] */ MatcherIndex(16), - /* [847] */ MatcherIndex(21), - /* [848] */ MatcherIndex(35), - /* [849] */ MatcherIndex(10), - /* [850] */ MatcherIndex(24), - /* [851] */ MatcherIndex(32), - /* [852] */ MatcherIndex(35), - /* [853] */ MatcherIndex(29), - /* [854] */ MatcherIndex(38), - /* [855] */ MatcherIndex(17), - /* [856] */ MatcherIndex(21), - /* [857] */ MatcherIndex(35), - /* [858] */ MatcherIndex(11), - /* [859] */ MatcherIndex(24), - /* [860] */ MatcherIndex(32), - /* [861] */ MatcherIndex(35), - /* [862] */ MatcherIndex(29), - /* [863] */ MatcherIndex(38), - /* [864] */ MatcherIndex(18), - /* [865] */ MatcherIndex(21), - /* [866] */ MatcherIndex(35), - /* [867] */ MatcherIndex(1), - /* [868] */ MatcherIndex(22), - /* [869] */ MatcherIndex(32), - /* [870] */ MatcherIndex(35), - /* [871] */ MatcherIndex(29), - /* [872] */ MatcherIndex(37), - /* [873] */ MatcherIndex(2), - /* [874] */ MatcherIndex(20), - /* [875] */ MatcherIndex(35), - /* [876] */ MatcherIndex(1), - /* [877] */ MatcherIndex(23), - /* [878] */ MatcherIndex(32), - /* [879] */ MatcherIndex(36), - /* [880] */ MatcherIndex(29), - /* [881] */ MatcherIndex(37), - /* [882] */ MatcherIndex(2), - /* [883] */ MatcherIndex(20), - /* [884] */ MatcherIndex(35), + /* [758] */ MatcherIndex(27), + /* [759] */ MatcherIndex(30), + /* [760] */ MatcherIndex(24), + /* [761] */ MatcherIndex(33), + /* [762] */ MatcherIndex(11), + /* [763] */ MatcherIndex(16), + /* [764] */ MatcherIndex(1), + /* [765] */ MatcherIndex(37), + /* [766] */ MatcherIndex(10), + /* [767] */ MatcherIndex(17), + /* [768] */ MatcherIndex(27), + /* [769] */ MatcherIndex(30), + /* [770] */ MatcherIndex(24), + /* [771] */ MatcherIndex(33), + /* [772] */ MatcherIndex(12), + /* [773] */ MatcherIndex(16), + /* [774] */ MatcherIndex(0), + /* [775] */ MatcherIndex(37), + /* [776] */ MatcherIndex(10), + /* [777] */ MatcherIndex(21), + /* [778] */ MatcherIndex(27), + /* [779] */ MatcherIndex(30), + /* [780] */ MatcherIndex(24), + /* [781] */ MatcherIndex(33), + /* [782] */ MatcherIndex(12), + /* [783] */ MatcherIndex(16), + /* [784] */ MatcherIndex(2), + /* [785] */ MatcherIndex(37), + /* [786] */ MatcherIndex(11), + /* [787] */ MatcherIndex(17), + /* [788] */ MatcherIndex(27), + /* [789] */ MatcherIndex(30), + /* [790] */ MatcherIndex(24), + /* [791] */ MatcherIndex(33), + /* [792] */ MatcherIndex(13), + /* [793] */ MatcherIndex(16), + /* [794] */ MatcherIndex(37), + /* [795] */ MatcherIndex(11), + /* [796] */ MatcherIndex(21), + /* [797] */ MatcherIndex(27), + /* [798] */ MatcherIndex(30), + /* [799] */ MatcherIndex(24), + /* [800] */ MatcherIndex(33), + /* [801] */ MatcherIndex(13), + /* [802] */ MatcherIndex(16), + /* [803] */ MatcherIndex(37), + /* [804] */ MatcherIndex(8), + /* [805] */ MatcherIndex(18), + /* [806] */ MatcherIndex(27), + /* [807] */ MatcherIndex(30), + /* [808] */ MatcherIndex(24), + /* [809] */ MatcherIndex(33), + /* [810] */ MatcherIndex(11), + /* [811] */ MatcherIndex(16), + /* [812] */ MatcherIndex(37), + /* [813] */ MatcherIndex(10), + /* [814] */ MatcherIndex(18), + /* [815] */ MatcherIndex(27), + /* [816] */ MatcherIndex(30), + /* [817] */ MatcherIndex(24), + /* [818] */ MatcherIndex(33), + /* [819] */ MatcherIndex(12), + /* [820] */ MatcherIndex(16), + /* [821] */ MatcherIndex(37), + /* [822] */ MatcherIndex(11), + /* [823] */ MatcherIndex(18), + /* [824] */ MatcherIndex(27), + /* [825] */ MatcherIndex(30), + /* [826] */ MatcherIndex(24), + /* [827] */ MatcherIndex(33), + /* [828] */ MatcherIndex(13), + /* [829] */ MatcherIndex(16), + /* [830] */ MatcherIndex(37), + /* [831] */ MatcherIndex(8), + /* [832] */ MatcherIndex(18), + /* [833] */ MatcherIndex(27), + /* [834] */ MatcherIndex(29), + /* [835] */ MatcherIndex(24), + /* [836] */ MatcherIndex(33), + /* [837] */ MatcherIndex(11), + /* [838] */ MatcherIndex(16), + /* [839] */ MatcherIndex(37), + /* [840] */ MatcherIndex(10), + /* [841] */ MatcherIndex(18), + /* [842] */ MatcherIndex(27), + /* [843] */ MatcherIndex(29), + /* [844] */ MatcherIndex(24), + /* [845] */ MatcherIndex(33), + /* [846] */ MatcherIndex(12), + /* [847] */ MatcherIndex(16), + /* [848] */ MatcherIndex(37), + /* [849] */ MatcherIndex(11), + /* [850] */ MatcherIndex(18), + /* [851] */ MatcherIndex(27), + /* [852] */ MatcherIndex(29), + /* [853] */ MatcherIndex(24), + /* [854] */ MatcherIndex(33), + /* [855] */ MatcherIndex(13), + /* [856] */ MatcherIndex(16), + /* [857] */ MatcherIndex(37), + /* [858] */ MatcherIndex(8), + /* [859] */ MatcherIndex(19), + /* [860] */ MatcherIndex(27), + /* [861] */ MatcherIndex(30), + /* [862] */ MatcherIndex(24), + /* [863] */ MatcherIndex(33), + /* [864] */ MatcherIndex(11), + /* [865] */ MatcherIndex(16), + /* [866] */ MatcherIndex(37), + /* [867] */ MatcherIndex(10), + /* [868] */ MatcherIndex(19), + /* [869] */ MatcherIndex(27), + /* [870] */ MatcherIndex(30), + /* [871] */ MatcherIndex(24), + /* [872] */ MatcherIndex(33), + /* [873] */ MatcherIndex(12), + /* [874] */ MatcherIndex(16), + /* [875] */ MatcherIndex(37), + /* [876] */ MatcherIndex(11), + /* [877] */ MatcherIndex(19), + /* [878] */ MatcherIndex(27), + /* [879] */ MatcherIndex(30), + /* [880] */ MatcherIndex(24), + /* [881] */ MatcherIndex(33), + /* [882] */ MatcherIndex(13), + /* [883] */ MatcherIndex(16), + /* [884] */ MatcherIndex(37), /* [885] */ MatcherIndex(1), - /* [886] */ MatcherIndex(24), - /* [887] */ MatcherIndex(32), - /* [888] */ MatcherIndex(35), - /* [889] */ MatcherIndex(29), - /* [890] */ MatcherIndex(37), + /* [886] */ MatcherIndex(17), + /* [887] */ MatcherIndex(27), + /* [888] */ MatcherIndex(30), + /* [889] */ MatcherIndex(24), + /* [890] */ MatcherIndex(32), /* [891] */ MatcherIndex(2), - /* [892] */ MatcherIndex(20), - /* [893] */ MatcherIndex(35), + /* [892] */ MatcherIndex(15), + /* [893] */ MatcherIndex(37), /* [894] */ MatcherIndex(1), - /* [895] */ MatcherIndex(25), - /* [896] */ MatcherIndex(32), - /* [897] */ MatcherIndex(36), - /* [898] */ MatcherIndex(29), - /* [899] */ MatcherIndex(37), + /* [895] */ MatcherIndex(18), + /* [896] */ MatcherIndex(27), + /* [897] */ MatcherIndex(31), + /* [898] */ MatcherIndex(24), + /* [899] */ MatcherIndex(32), /* [900] */ MatcherIndex(2), - /* [901] */ MatcherIndex(20), - /* [902] */ MatcherIndex(35), - /* [903] */ MatcherIndex(8), - /* [904] */ MatcherIndex(23), - /* [905] */ MatcherIndex(31), - /* [906] */ MatcherIndex(36), - /* [907] */ MatcherIndex(29), - /* [908] */ MatcherIndex(37), - /* [909] */ MatcherIndex(1), - /* [910] */ MatcherIndex(20), - /* [911] */ MatcherIndex(35), - /* [912] */ MatcherIndex(8), - /* [913] */ MatcherIndex(25), - /* [914] */ MatcherIndex(31), - /* [915] */ MatcherIndex(36), - /* [916] */ MatcherIndex(29), - /* [917] */ MatcherIndex(37), - /* [918] */ MatcherIndex(1), - /* [919] */ MatcherIndex(20), - /* [920] */ MatcherIndex(35), - /* [921] */ MatcherIndex(1), - /* [922] */ MatcherIndex(22), - /* [923] */ MatcherIndex(32), - /* [924] */ MatcherIndex(35), - /* [925] */ MatcherIndex(29), - /* [926] */ MatcherIndex(37), - /* [927] */ MatcherIndex(3), - /* [928] */ MatcherIndex(20), - /* [929] */ MatcherIndex(35), - /* [930] */ MatcherIndex(1), - /* [931] */ MatcherIndex(23), - /* [932] */ MatcherIndex(32), - /* [933] */ MatcherIndex(36), - /* [934] */ MatcherIndex(29), - /* [935] */ MatcherIndex(37), - /* [936] */ MatcherIndex(3), - /* [937] */ MatcherIndex(20), - /* [938] */ MatcherIndex(35), + /* [901] */ MatcherIndex(15), + /* [902] */ MatcherIndex(37), + /* [903] */ MatcherIndex(1), + /* [904] */ MatcherIndex(19), + /* [905] */ MatcherIndex(27), + /* [906] */ MatcherIndex(30), + /* [907] */ MatcherIndex(24), + /* [908] */ MatcherIndex(32), + /* [909] */ MatcherIndex(2), + /* [910] */ MatcherIndex(15), + /* [911] */ MatcherIndex(37), + /* [912] */ MatcherIndex(1), + /* [913] */ MatcherIndex(20), + /* [914] */ MatcherIndex(27), + /* [915] */ MatcherIndex(31), + /* [916] */ MatcherIndex(24), + /* [917] */ MatcherIndex(32), + /* [918] */ MatcherIndex(2), + /* [919] */ MatcherIndex(15), + /* [920] */ MatcherIndex(37), + /* [921] */ MatcherIndex(8), + /* [922] */ MatcherIndex(18), + /* [923] */ MatcherIndex(26), + /* [924] */ MatcherIndex(31), + /* [925] */ MatcherIndex(24), + /* [926] */ MatcherIndex(32), + /* [927] */ MatcherIndex(1), + /* [928] */ MatcherIndex(15), + /* [929] */ MatcherIndex(37), + /* [930] */ MatcherIndex(8), + /* [931] */ MatcherIndex(20), + /* [932] */ MatcherIndex(26), + /* [933] */ MatcherIndex(31), + /* [934] */ MatcherIndex(24), + /* [935] */ MatcherIndex(32), + /* [936] */ MatcherIndex(1), + /* [937] */ MatcherIndex(15), + /* [938] */ MatcherIndex(37), /* [939] */ MatcherIndex(1), - /* [940] */ MatcherIndex(24), - /* [941] */ MatcherIndex(32), - /* [942] */ MatcherIndex(35), - /* [943] */ MatcherIndex(29), - /* [944] */ MatcherIndex(37), + /* [940] */ MatcherIndex(17), + /* [941] */ MatcherIndex(27), + /* [942] */ MatcherIndex(30), + /* [943] */ MatcherIndex(24), + /* [944] */ MatcherIndex(32), /* [945] */ MatcherIndex(3), - /* [946] */ MatcherIndex(20), - /* [947] */ MatcherIndex(35), + /* [946] */ MatcherIndex(15), + /* [947] */ MatcherIndex(37), /* [948] */ MatcherIndex(1), - /* [949] */ MatcherIndex(25), - /* [950] */ MatcherIndex(32), - /* [951] */ MatcherIndex(36), - /* [952] */ MatcherIndex(29), - /* [953] */ MatcherIndex(37), + /* [949] */ MatcherIndex(18), + /* [950] */ MatcherIndex(27), + /* [951] */ MatcherIndex(31), + /* [952] */ MatcherIndex(24), + /* [953] */ MatcherIndex(32), /* [954] */ MatcherIndex(3), - /* [955] */ MatcherIndex(20), - /* [956] */ MatcherIndex(35), - /* [957] */ MatcherIndex(8), - /* [958] */ MatcherIndex(23), - /* [959] */ MatcherIndex(31), - /* [960] */ MatcherIndex(36), - /* [961] */ MatcherIndex(29), - /* [962] */ MatcherIndex(37), - /* [963] */ MatcherIndex(2), - /* [964] */ MatcherIndex(20), - /* [965] */ MatcherIndex(35), - /* [966] */ MatcherIndex(8), - /* [967] */ MatcherIndex(25), - /* [968] */ MatcherIndex(31), - /* [969] */ MatcherIndex(36), - /* [970] */ MatcherIndex(29), - /* [971] */ MatcherIndex(37), - /* [972] */ MatcherIndex(2), - /* [973] */ MatcherIndex(20), - /* [974] */ MatcherIndex(33), - /* [975] */ MatcherIndex(2), - /* [976] */ MatcherIndex(27), - /* [977] */ MatcherIndex(1), - /* [978] */ MatcherIndex(0), - /* [979] */ MatcherIndex(21), - /* [980] */ MatcherIndex(33), - /* [981] */ MatcherIndex(3), - /* [982] */ MatcherIndex(27), - /* [983] */ MatcherIndex(2), - /* [984] */ MatcherIndex(1), - /* [985] */ MatcherIndex(21), - /* [986] */ MatcherIndex(33), - /* [987] */ MatcherIndex(2), - /* [988] */ MatcherIndex(29), - /* [989] */ MatcherIndex(0), - /* [990] */ MatcherIndex(19), - /* [991] */ MatcherIndex(33), - /* [992] */ MatcherIndex(13), - /* [993] */ MatcherIndex(29), - /* [994] */ MatcherIndex(12), - /* [995] */ MatcherIndex(19), - /* [996] */ MatcherIndex(37), - /* [997] */ MatcherIndex(1), - /* [998] */ MatcherIndex(2), + /* [955] */ MatcherIndex(15), + /* [956] */ MatcherIndex(37), + /* [957] */ MatcherIndex(1), + /* [958] */ MatcherIndex(19), + /* [959] */ MatcherIndex(27), + /* [960] */ MatcherIndex(30), + /* [961] */ MatcherIndex(24), + /* [962] */ MatcherIndex(32), + /* [963] */ MatcherIndex(3), + /* [964] */ MatcherIndex(15), + /* [965] */ MatcherIndex(37), + /* [966] */ MatcherIndex(1), + /* [967] */ MatcherIndex(20), + /* [968] */ MatcherIndex(27), + /* [969] */ MatcherIndex(31), + /* [970] */ MatcherIndex(24), + /* [971] */ MatcherIndex(32), + /* [972] */ MatcherIndex(3), + /* [973] */ MatcherIndex(15), + /* [974] */ MatcherIndex(37), + /* [975] */ MatcherIndex(8), + /* [976] */ MatcherIndex(18), + /* [977] */ MatcherIndex(26), + /* [978] */ MatcherIndex(31), + /* [979] */ MatcherIndex(24), + /* [980] */ MatcherIndex(32), + /* [981] */ MatcherIndex(2), + /* [982] */ MatcherIndex(15), + /* [983] */ MatcherIndex(37), + /* [984] */ MatcherIndex(8), + /* [985] */ MatcherIndex(20), + /* [986] */ MatcherIndex(26), + /* [987] */ MatcherIndex(31), + /* [988] */ MatcherIndex(24), + /* [989] */ MatcherIndex(32), + /* [990] */ MatcherIndex(2), + /* [991] */ MatcherIndex(15), + /* [992] */ MatcherIndex(33), + /* [993] */ MatcherIndex(2), + /* [994] */ MatcherIndex(27), + /* [995] */ MatcherIndex(1), + /* [996] */ MatcherIndex(0), + /* [997] */ MatcherIndex(3), + /* [998] */ MatcherIndex(33), /* [999] */ MatcherIndex(3), - /* [1000] */ MatcherIndex(4), - /* [1001] */ MatcherIndex(37), - /* [1002] */ MatcherIndex(0), - /* [1003] */ MatcherIndex(1), - /* [1004] */ MatcherIndex(2), - /* [1005] */ MatcherIndex(3), - /* [1006] */ MatcherIndex(37), - /* [1007] */ MatcherIndex(41), - /* [1008] */ MatcherIndex(1), - /* [1009] */ MatcherIndex(2), - /* [1010] */ MatcherIndex(3), - /* [1011] */ MatcherIndex(37), - /* [1012] */ MatcherIndex(39), + /* [1000] */ MatcherIndex(27), + /* [1001] */ MatcherIndex(2), + /* [1002] */ MatcherIndex(1), + /* [1003] */ MatcherIndex(4), + /* [1004] */ MatcherIndex(33), + /* [1005] */ MatcherIndex(8), + /* [1006] */ MatcherIndex(27), + /* [1007] */ MatcherIndex(1), + /* [1008] */ MatcherIndex(0), + /* [1009] */ MatcherIndex(15), + /* [1010] */ MatcherIndex(33), + /* [1011] */ MatcherIndex(2), + /* [1012] */ MatcherIndex(29), /* [1013] */ MatcherIndex(0), - /* [1014] */ MatcherIndex(4), - /* [1015] */ MatcherIndex(3), - /* [1016] */ MatcherIndex(37), - /* [1017] */ MatcherIndex(40), - /* [1018] */ MatcherIndex(0), - /* [1019] */ MatcherIndex(2), - /* [1020] */ MatcherIndex(4), - /* [1021] */ MatcherIndex(37), - /* [1022] */ MatcherIndex(0), - /* [1023] */ MatcherIndex(13), - /* [1024] */ MatcherIndex(1), - /* [1025] */ MatcherIndex(2), - /* [1026] */ MatcherIndex(37), - /* [1027] */ MatcherIndex(0), - /* [1028] */ MatcherIndex(14), - /* [1029] */ MatcherIndex(1), - /* [1030] */ MatcherIndex(2), - /* [1031] */ MatcherIndex(33), - /* [1032] */ MatcherIndex(13), - /* [1033] */ MatcherIndex(34), - /* [1034] */ MatcherIndex(1), - /* [1035] */ MatcherIndex(33), - /* [1036] */ MatcherIndex(2), + /* [1014] */ MatcherIndex(14), + /* [1015] */ MatcherIndex(33), + /* [1016] */ MatcherIndex(7), + /* [1017] */ MatcherIndex(29), + /* [1018] */ MatcherIndex(12), + /* [1019] */ MatcherIndex(14), + /* [1020] */ MatcherIndex(39), + /* [1021] */ MatcherIndex(1), + /* [1022] */ MatcherIndex(2), + /* [1023] */ MatcherIndex(3), + /* [1024] */ MatcherIndex(4), + /* [1025] */ MatcherIndex(39), + /* [1026] */ MatcherIndex(0), + /* [1027] */ MatcherIndex(1), + /* [1028] */ MatcherIndex(2), + /* [1029] */ MatcherIndex(3), + /* [1030] */ MatcherIndex(39), + /* [1031] */ MatcherIndex(36), + /* [1032] */ MatcherIndex(1), + /* [1033] */ MatcherIndex(2), + /* [1034] */ MatcherIndex(3), + /* [1035] */ MatcherIndex(39), + /* [1036] */ MatcherIndex(34), /* [1037] */ MatcherIndex(0), - /* [1038] */ MatcherIndex(20), - /* [1039] */ MatcherIndex(33), - /* [1040] */ MatcherIndex(2), - /* [1041] */ MatcherIndex(0), - /* [1042] */ MatcherIndex(21), - /* [1043] */ MatcherIndex(28), - /* [1044] */ MatcherIndex(2), - /* [1045] */ MatcherIndex(3), + /* [1038] */ MatcherIndex(4), + /* [1039] */ MatcherIndex(3), + /* [1040] */ MatcherIndex(39), + /* [1041] */ MatcherIndex(35), + /* [1042] */ MatcherIndex(0), + /* [1043] */ MatcherIndex(2), + /* [1044] */ MatcherIndex(4), + /* [1045] */ MatcherIndex(39), /* [1046] */ MatcherIndex(0), - /* [1047] */ MatcherIndex(28), + /* [1047] */ MatcherIndex(13), /* [1048] */ MatcherIndex(1), - /* [1049] */ MatcherIndex(3), - /* [1050] */ MatcherIndex(0), - /* [1051] */ MatcherIndex(28), - /* [1052] */ MatcherIndex(2), + /* [1049] */ MatcherIndex(2), + /* [1050] */ MatcherIndex(39), + /* [1051] */ MatcherIndex(0), + /* [1052] */ MatcherIndex(14), /* [1053] */ MatcherIndex(1), - /* [1054] */ MatcherIndex(0), - /* [1055] */ MatcherIndex(28), - /* [1056] */ MatcherIndex(1), - /* [1057] */ MatcherIndex(2), + /* [1054] */ MatcherIndex(2), + /* [1055] */ MatcherIndex(33), + /* [1056] */ MatcherIndex(7), + /* [1057] */ MatcherIndex(34), /* [1058] */ MatcherIndex(0), /* [1059] */ MatcherIndex(33), - /* [1060] */ MatcherIndex(1), + /* [1060] */ MatcherIndex(2), /* [1061] */ MatcherIndex(0), - /* [1062] */ MatcherIndex(21), + /* [1062] */ MatcherIndex(3), /* [1063] */ MatcherIndex(33), /* [1064] */ MatcherIndex(2), - /* [1065] */ MatcherIndex(1), - /* [1066] */ MatcherIndex(21), - /* [1067] */ MatcherIndex(33), - /* [1068] */ MatcherIndex(14), - /* [1069] */ MatcherIndex(2), - /* [1070] */ MatcherIndex(20), - /* [1071] */ MatcherIndex(33), - /* [1072] */ MatcherIndex(14), - /* [1073] */ MatcherIndex(10), - /* [1074] */ MatcherIndex(20), - /* [1075] */ MatcherIndex(33), - /* [1076] */ MatcherIndex(14), - /* [1077] */ MatcherIndex(11), - /* [1078] */ MatcherIndex(20), - /* [1079] */ MatcherIndex(33), - /* [1080] */ MatcherIndex(14), - /* [1081] */ MatcherIndex(1), - /* [1082] */ MatcherIndex(21), + /* [1065] */ MatcherIndex(0), + /* [1066] */ MatcherIndex(14), + /* [1067] */ MatcherIndex(28), + /* [1068] */ MatcherIndex(2), + /* [1069] */ MatcherIndex(3), + /* [1070] */ MatcherIndex(0), + /* [1071] */ MatcherIndex(28), + /* [1072] */ MatcherIndex(1), + /* [1073] */ MatcherIndex(3), + /* [1074] */ MatcherIndex(0), + /* [1075] */ MatcherIndex(28), + /* [1076] */ MatcherIndex(2), + /* [1077] */ MatcherIndex(1), + /* [1078] */ MatcherIndex(0), + /* [1079] */ MatcherIndex(28), + /* [1080] */ MatcherIndex(1), + /* [1081] */ MatcherIndex(2), + /* [1082] */ MatcherIndex(0), /* [1083] */ MatcherIndex(33), - /* [1084] */ MatcherIndex(14), - /* [1085] */ MatcherIndex(10), - /* [1086] */ MatcherIndex(21), + /* [1084] */ MatcherIndex(1), + /* [1085] */ MatcherIndex(0), + /* [1086] */ MatcherIndex(2), /* [1087] */ MatcherIndex(33), - /* [1088] */ MatcherIndex(14), - /* [1089] */ MatcherIndex(11), - /* [1090] */ MatcherIndex(21), - /* [1091] */ MatcherIndex(27), - /* [1092] */ MatcherIndex(0), - /* [1093] */ MatcherIndex(1), - /* [1094] */ MatcherIndex(27), - /* [1095] */ MatcherIndex(2), - /* [1096] */ MatcherIndex(8), - /* [1097] */ MatcherIndex(27), - /* [1098] */ MatcherIndex(3), - /* [1099] */ MatcherIndex(8), - /* [1100] */ MatcherIndex(27), - /* [1101] */ MatcherIndex(1), - /* [1102] */ MatcherIndex(8), - /* [1103] */ MatcherIndex(27), - /* [1104] */ MatcherIndex(2), - /* [1105] */ MatcherIndex(0), - /* [1106] */ MatcherIndex(27), - /* [1107] */ MatcherIndex(0), - /* [1108] */ MatcherIndex(7), - /* [1109] */ MatcherIndex(27), - /* [1110] */ MatcherIndex(3), - /* [1111] */ MatcherIndex(0), - /* [1112] */ MatcherIndex(27), - /* [1113] */ MatcherIndex(3), - /* [1114] */ MatcherIndex(1), - /* [1115] */ MatcherIndex(27), - /* [1116] */ MatcherIndex(3), - /* [1117] */ MatcherIndex(2), - /* [1118] */ MatcherIndex(27), - /* [1119] */ MatcherIndex(4), + /* [1088] */ MatcherIndex(2), + /* [1089] */ MatcherIndex(1), + /* [1090] */ MatcherIndex(3), + /* [1091] */ MatcherIndex(33), + /* [1092] */ MatcherIndex(5), + /* [1093] */ MatcherIndex(2), + /* [1094] */ MatcherIndex(6), + /* [1095] */ MatcherIndex(33), + /* [1096] */ MatcherIndex(5), + /* [1097] */ MatcherIndex(10), + /* [1098] */ MatcherIndex(6), + /* [1099] */ MatcherIndex(33), + /* [1100] */ MatcherIndex(5), + /* [1101] */ MatcherIndex(11), + /* [1102] */ MatcherIndex(6), + /* [1103] */ MatcherIndex(33), + /* [1104] */ MatcherIndex(4), + /* [1105] */ MatcherIndex(1), + /* [1106] */ MatcherIndex(5), + /* [1107] */ MatcherIndex(33), + /* [1108] */ MatcherIndex(4), + /* [1109] */ MatcherIndex(10), + /* [1110] */ MatcherIndex(5), + /* [1111] */ MatcherIndex(33), + /* [1112] */ MatcherIndex(4), + /* [1113] */ MatcherIndex(11), + /* [1114] */ MatcherIndex(5), + /* [1115] */ MatcherIndex(33), + /* [1116] */ MatcherIndex(8), + /* [1117] */ MatcherIndex(0), + /* [1118] */ MatcherIndex(15), + /* [1119] */ MatcherIndex(27), /* [1120] */ MatcherIndex(0), - /* [1121] */ MatcherIndex(27), - /* [1122] */ MatcherIndex(4), - /* [1123] */ MatcherIndex(1), - /* [1124] */ MatcherIndex(27), - /* [1125] */ MatcherIndex(4), - /* [1126] */ MatcherIndex(2), - /* [1127] */ MatcherIndex(27), - /* [1128] */ MatcherIndex(4), - /* [1129] */ MatcherIndex(3), - /* [1130] */ MatcherIndex(27), - /* [1131] */ MatcherIndex(0), + /* [1121] */ MatcherIndex(1), + /* [1122] */ MatcherIndex(27), + /* [1123] */ MatcherIndex(2), + /* [1124] */ MatcherIndex(8), + /* [1125] */ MatcherIndex(27), + /* [1126] */ MatcherIndex(3), + /* [1127] */ MatcherIndex(8), + /* [1128] */ MatcherIndex(27), + /* [1129] */ MatcherIndex(1), + /* [1130] */ MatcherIndex(8), + /* [1131] */ MatcherIndex(27), /* [1132] */ MatcherIndex(2), - /* [1133] */ MatcherIndex(27), - /* [1134] */ MatcherIndex(2), - /* [1135] */ MatcherIndex(7), - /* [1136] */ MatcherIndex(17), - /* [1137] */ MatcherIndex(8), - /* [1138] */ MatcherIndex(15), - /* [1139] */ MatcherIndex(8), - /* [1140] */ MatcherIndex(15), - /* [1141] */ MatcherIndex(2), - /* [1142] */ MatcherIndex(16), - /* [1143] */ MatcherIndex(8), - /* [1144] */ MatcherIndex(17), - /* [1145] */ MatcherIndex(0), - /* [1146] */ MatcherIndex(15), - /* [1147] */ MatcherIndex(1), - /* [1148] */ MatcherIndex(16), - /* [1149] */ MatcherIndex(1), - /* [1150] */ MatcherIndex(15), - /* [1151] */ MatcherIndex(0), - /* [1152] */ MatcherIndex(16), - /* [1153] */ MatcherIndex(0), - /* [1154] */ MatcherIndex(17), - /* [1155] */ MatcherIndex(10), - /* [1156] */ MatcherIndex(17), - /* [1157] */ MatcherIndex(11), - /* [1158] */ MatcherIndex(16), - /* [1159] */ MatcherIndex(2), - /* [1160] */ MatcherIndex(17), - /* [1161] */ MatcherIndex(1), - /* [1162] */ MatcherIndex(36), - /* [1163] */ MatcherIndex(0), - /* [1164] */ MatcherIndex(31), - /* [1165] */ MatcherIndex(2), - /* [1166] */ MatcherIndex(18), - /* [1167] */ MatcherIndex(0), - /* [1168] */ MatcherIndex(22), - /* [1169] */ MatcherIndex(0), - /* [1170] */ MatcherIndex(26), - /* [1171] */ MatcherIndex(0), - /* [1172] */ MatcherIndex(45), - /* [1173] */ MatcherIndex(42), - /* [1174] */ MatcherIndex(9), - /* [1175] */ MatcherIndex(44), - /* [1176] */ MatcherIndex(43), + /* [1133] */ MatcherIndex(0), + /* [1134] */ MatcherIndex(27), + /* [1135] */ MatcherIndex(0), + /* [1136] */ MatcherIndex(7), + /* [1137] */ MatcherIndex(27), + /* [1138] */ MatcherIndex(3), + /* [1139] */ MatcherIndex(0), + /* [1140] */ MatcherIndex(27), + /* [1141] */ MatcherIndex(3), + /* [1142] */ MatcherIndex(1), + /* [1143] */ MatcherIndex(27), + /* [1144] */ MatcherIndex(3), + /* [1145] */ MatcherIndex(2), + /* [1146] */ MatcherIndex(27), + /* [1147] */ MatcherIndex(4), + /* [1148] */ MatcherIndex(0), + /* [1149] */ MatcherIndex(27), + /* [1150] */ MatcherIndex(4), + /* [1151] */ MatcherIndex(1), + /* [1152] */ MatcherIndex(27), + /* [1153] */ MatcherIndex(4), + /* [1154] */ MatcherIndex(2), + /* [1155] */ MatcherIndex(27), + /* [1156] */ MatcherIndex(4), + /* [1157] */ MatcherIndex(3), + /* [1158] */ MatcherIndex(27), + /* [1159] */ MatcherIndex(0), + /* [1160] */ MatcherIndex(2), + /* [1161] */ MatcherIndex(27), + /* [1162] */ MatcherIndex(2), + /* [1163] */ MatcherIndex(7), + /* [1164] */ MatcherIndex(36), + /* [1165] */ MatcherIndex(1), + /* [1166] */ MatcherIndex(0), + /* [1167] */ MatcherIndex(17), + /* [1168] */ MatcherIndex(8), + /* [1169] */ MatcherIndex(17), + /* [1170] */ MatcherIndex(0), + /* [1171] */ MatcherIndex(17), + /* [1172] */ MatcherIndex(10), + /* [1173] */ MatcherIndex(17), + /* [1174] */ MatcherIndex(11), + /* [1175] */ MatcherIndex(17), + /* [1176] */ MatcherIndex(1), + /* [1177] */ MatcherIndex(38), + /* [1178] */ MatcherIndex(0), + /* [1179] */ MatcherIndex(18), + /* [1180] */ MatcherIndex(0), + /* [1181] */ MatcherIndex(22), + /* [1182] */ MatcherIndex(0), + /* [1183] */ MatcherIndex(26), + /* [1184] */ MatcherIndex(0), + /* [1185] */ MatcherIndex(41), + /* [1186] */ MatcherIndex(9), + /* [1187] */ MatcherIndex(40), + /* [1188] */ MatcherIndex(42), + /* [1189] */ MatcherIndex(47), + /* [1190] */ MatcherIndex(44), + /* [1191] */ MatcherIndex(43), + /* [1192] */ MatcherIndex(46), + /* [1193] */ MatcherIndex(45), }; static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices), @@ -2698,25 +2681,25 @@ constexpr ParameterInfo kParameters[] = { /* [0] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(986), + /* matcher_indices */ MatcherIndicesIndex(1010), }, { /* [1] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [2] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [3] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [4] */ @@ -2740,31 +2723,31 @@ constexpr ParameterInfo kParameters[] = { /* [7] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [8] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1039), + /* matcher_indices */ MatcherIndicesIndex(1063), }, { /* [9] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [10] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [11] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [12] */ @@ -2782,4993 +2765,4993 @@ constexpr ParameterInfo kParameters[] = { /* [14] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1164), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [15] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [16] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1097), + /* matcher_indices */ MatcherIndicesIndex(54), }, { /* [17] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [18] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(1125), }, { /* [19] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [20] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [21] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [22] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [23] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(65), }, { /* [24] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [25] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [26] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [27] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [28] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [29] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(65), }, { /* [30] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [31] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [32] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [33] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [34] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [35] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(205), }, { /* [36] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [37] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [38] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [39] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [40] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [41] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(205), }, { /* [42] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [43] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [44] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [45] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [46] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [47] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [48] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [49] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [50] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [51] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [52] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [53] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [54] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [55] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [56] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [57] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [58] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [59] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(275), }, { /* [60] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [61] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [62] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [63] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), - }, - { - /* [64] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [65] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [66] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [64] */ + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [65] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(275), + }, + { + /* [66] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [67] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [68] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [69] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), - }, - { - /* [70] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), - }, - { - /* [71] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [72] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [70] */ + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [71] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(275), + }, + { + /* [72] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1122), }, { /* [73] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [74] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [75] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(280), - }, - { - /* [76] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [77] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [78] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [76] */ + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [77] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(285), + }, + { + /* [78] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [79] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [80] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [81] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(280), - }, - { - /* [82] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [83] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [84] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [82] */ + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [83] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(285), + }, + { + /* [84] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [85] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [86] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [87] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(0), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [88] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [89] */ - /* usage */ core::ParameterUsage::kDref, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [90] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [91] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), - }, - { - /* [92] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [93] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [94] */ - /* usage */ core::ParameterUsage::kDref, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [95] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [96] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), - }, - { - /* [97] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(50), - }, - { - /* [98] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [99] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), - }, - { - /* [100] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [101] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), - }, - { - /* [102] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(70), - }, - { - /* [103] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [104] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), - }, - { - /* [105] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [106] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), - }, - { - /* [107] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(110), - }, - { - /* [108] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [109] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), - }, - { - /* [110] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [111] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [112] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(130), - }, - { - /* [113] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [114] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), - }, - { - /* [115] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [116] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [117] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [118] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1097), - }, - { - /* [119] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [120] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [121] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [122] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), - }, - { - /* [123] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [124] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [125] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [126] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [127] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), - }, - { - /* [128] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [129] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [130] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [131] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [132] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), - }, - { - /* [133] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [134] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [135] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [136] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), - }, - { - /* [137] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), - }, - { - /* [138] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [139] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [140] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [141] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), - }, - { - /* [142] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [143] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [144] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [145] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [146] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [147] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [148] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [149] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [150] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [151] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [152] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), - }, - { - /* [153] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [154] */ - /* usage */ core::ParameterUsage::kDref, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [155] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [156] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [157] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), - }, - { - /* [158] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [159] */ - /* usage */ core::ParameterUsage::kDref, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [160] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [161] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [162] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), - }, - { - /* [163] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), - }, - { - /* [164] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [165] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [166] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [167] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [168] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1097), - }, - { - /* [169] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [170] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [171] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [172] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), - }, - { - /* [173] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [174] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [175] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [176] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [177] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), - }, - { - /* [178] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [179] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [180] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [181] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [182] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), - }, - { - /* [183] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [184] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [185] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [186] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [187] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), - }, - { - /* [188] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [189] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [190] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [191] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [192] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(190), - }, - { - /* [193] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [194] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [195] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [196] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [197] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(190), - }, - { - /* [198] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [199] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [200] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [201] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [202] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), - }, - { - /* [203] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [204] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [205] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [206] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), - }, - { - /* [207] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), - }, - { - /* [208] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [209] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [210] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [211] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), - }, - { - /* [212] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [213] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [214] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [215] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [216] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [217] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), - }, - { - /* [218] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [219] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [220] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [221] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [222] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(220), - }, - { - /* [223] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [224] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [225] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [226] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [227] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [228] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), - }, - { - /* [229] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [230] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [231] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [232] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(120), - }, - { - /* [233] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [234] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [235] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [236] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [237] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(120), - }, - { - /* [238] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [239] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [240] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [241] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [242] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), - }, - { - /* [243] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [244] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [245] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [246] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [247] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), - }, - { - /* [248] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [249] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [250] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [251] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), - }, - { - /* [252] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [253] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [254] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [255] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [256] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [257] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [258] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [259] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [260] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [261] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), - }, - { - /* [262] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [263] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [264] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [265] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [266] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [267] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), - }, - { - /* [268] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [269] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [270] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [271] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [272] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(0), }, { - /* [273] */ + /* [90] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(9), }, { - /* [274] */ + /* [91] */ /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [275] */ + /* [92] */ /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [93] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(20), + }, + { + /* [94] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(11), + }, + { + /* [95] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [96] */ + /* usage */ core::ParameterUsage::kDref, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [97] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [98] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(20), + }, + { + /* [99] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(55), + }, + { + /* [100] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [101] */ + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(32), + }, + { + /* [102] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [103] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(20), + }, + { + /* [104] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(75), + }, + { + /* [105] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [106] */ + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(32), + }, + { + /* [107] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [108] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(20), + }, + { + /* [109] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(115), + }, + { + /* [110] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [111] */ + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(8), + }, + { + /* [112] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [113] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [114] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(135), + }, + { + /* [115] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [116] */ + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(8), + }, + { + /* [117] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [118] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [119] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(44), + }, + { + /* [120] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1125), + }, + { + /* [121] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [122] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [123] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [124] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(65), + }, + { + /* [125] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [126] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [127] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [128] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [129] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(65), + }, + { + /* [130] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [131] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [132] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [133] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [134] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(205), + }, + { + /* [135] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [136] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [137] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [138] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(763), + }, + { + /* [139] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(205), + }, + { + /* [140] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [141] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [142] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [143] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(763), + }, + { + /* [144] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(44), + }, + { + /* [145] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [146] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [147] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [148] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [149] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(44), + }, + { + /* [150] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [151] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [152] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [153] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [154] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(275), + }, + { + /* [155] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [156] */ + /* usage */ core::ParameterUsage::kDref, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [157] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [158] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [159] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(275), + }, + { + /* [160] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [161] */ + /* usage */ core::ParameterUsage::kDref, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [162] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [163] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [164] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(175), + }, + { + /* [165] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1122), + }, + { + /* [166] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [167] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [168] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [169] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(44), + }, + { + /* [170] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1125), + }, + { + /* [171] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [172] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [173] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [174] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(185), + }, + { + /* [175] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [176] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [177] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [178] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [179] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(185), + }, + { + /* [180] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [181] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [182] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [183] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [184] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(65), + }, + { + /* [185] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [186] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [187] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [188] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [189] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(65), + }, + { + /* [190] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [191] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [192] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [193] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [194] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(195), + }, + { + /* [195] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [196] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [197] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [198] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [199] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(195), + }, + { + /* [200] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [201] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [202] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [203] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [204] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(205), + }, + { + /* [205] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [206] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [207] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [208] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(763), + }, + { + /* [209] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(205), + }, + { + /* [210] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [211] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [212] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [213] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(763), + }, + { + /* [214] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(215), + }, + { + /* [215] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [216] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [217] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [218] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [219] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(215), + }, + { + /* [220] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [221] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [222] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [223] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [224] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(225), + }, + { + /* [225] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [226] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [227] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [228] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [229] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(105), + }, + { + /* [230] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1122), + }, + { + /* [231] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [232] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [233] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [234] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(125), + }, + { + /* [235] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [236] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [237] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [238] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [239] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(125), + }, + { + /* [240] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [241] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [242] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [243] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [244] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(175), + }, + { + /* [245] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [246] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [247] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [248] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [249] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(175), + }, + { + /* [250] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [251] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [252] */ + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [253] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [254] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(44), + }, + { + /* [255] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [256] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [257] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [258] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [259] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(44), + }, + { + /* [260] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [261] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [262] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [263] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(31), + }, + { + /* [264] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(105), + }, + { + /* [265] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [266] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [267] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [268] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [269] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(105), + }, + { + /* [270] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [271] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [272] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [273] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [274] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(0), + }, + { + /* [275] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [276] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [277] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [278] */ + /* usage */ core::ParameterUsage::kLod, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(2), + }, + { + /* [279] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(0), }, { - /* [278] */ + /* [280] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [279] */ - /* usage */ core::ParameterUsage::kDref, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [280] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [281] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [282] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(270), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [283] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [284] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(275), }, { /* [285] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1122), }, { /* [286] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [287] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(280), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [288] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [289] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(285), }, { /* [290] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [291] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), - }, - { - /* [292] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(280), - }, - { - /* [293] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [294] */ /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [295] */ + /* [292] */ /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [293] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [294] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(285), + }, + { + /* [295] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [296] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [297] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [298] */ + /* usage */ core::ParameterUsage::kConstOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [299] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(0), }, { - /* [298] */ + /* [300] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1100), - }, - { - /* [299] */ - /* usage */ core::ParameterUsage::kDref, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [300] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1128), }, { /* [301] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [302] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [303] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [304] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [305] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [304] */ + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(11), + }, + { + /* [305] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [306] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [307] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [308] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [309] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [310] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [309] */ + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(11), + }, + { + /* [310] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [311] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [312] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [313] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [314] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [315] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [314] */ + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(22), + }, + { + /* [315] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [316] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [317] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [318] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [319] */ - /* usage */ core::ParameterUsage::kDref, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [320] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* [319] */ + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(22), + }, + { + /* [320] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [321] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [322] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(30), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [323] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [324] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(33), + }, + { + /* [325] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), + }, + { + /* [326] */ /* usage */ core::ParameterUsage::kDref, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [325] */ + /* [327] */ /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [326] */ - /* usage */ core::ParameterUsage::kLod, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), - }, - { - /* [327] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1079), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [328] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1001), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [329] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1103), }, { /* [330] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1025), }, { /* [331] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [332] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1083), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [333] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1001), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [334] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1107), }, { /* [335] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1025), }, { /* [336] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [337] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1087), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [338] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1001), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [339] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1111), }, { /* [340] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1025), }, { /* [341] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [342] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(986), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [343] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [344] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(1010), }, { /* [345] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [346] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [347] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [348] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(58), + /* matcher_indices */ MatcherIndicesIndex(1059), }, { /* [349] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1039), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [350] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [351] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [352] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1063), }, { /* [353] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(991), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [354] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [355] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [356] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(994), + /* matcher_indices */ MatcherIndicesIndex(1015), }, { /* [357] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(317), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [358] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [359] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(772), }, { /* [360] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(322), }, { /* [361] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(51), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [362] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [363] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [364] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(56), }, { /* [365] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(71), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [366] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [367] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [368] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(76), }, { /* [369] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(326), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [370] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [371] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [372] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(331), }, { /* [373] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(335), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [374] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [375] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [376] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(340), }, { /* [377] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(111), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [378] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [379] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [380] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(116), }, { /* [381] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(131), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [382] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [383] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [384] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(136), }, { /* [385] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(344), + /* matcher_indices */ MatcherIndicesIndex(773), }, { /* [386] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [387] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [388] */ - /* usage */ core::ParameterUsage::kSample, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(349), }, { /* [389] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [390] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [391] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [392] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [393] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [394] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [395] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [396] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(65), }, { /* [397] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(80), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [398] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [399] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [400] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(85), }, { /* [401] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(90), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [402] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [403] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [404] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(95), }, { /* [405] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [406] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1138), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [407] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [408] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(105), }, { /* [409] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(120), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [410] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [411] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [412] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(125), }, { /* [413] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(140), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [414] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [415] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [416] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(145), }, { /* [417] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(150), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [418] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), - }, - { - /* [419] */ /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(8), }, { - /* [420] */ + /* [419] */ /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [420] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(155), }, { /* [421] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [422] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kComponent, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [423] */ /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [424] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(736), }, { /* [425] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(53), }, { /* [426] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1097), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [427] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kSample, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [428] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(175), }, { /* [429] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), + /* matcher_indices */ MatcherIndicesIndex(1122), }, { /* [430] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [431] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [432] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [433] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), + /* matcher_indices */ MatcherIndicesIndex(1125), }, { /* [434] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [435] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [436] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(185), }, { /* [437] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [438] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [439] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [440] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(185), }, { /* [441] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [442] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [443] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [444] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(65), }, { /* [445] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(190), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [446] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [447] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [448] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(65), }, { /* [449] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(190), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [450] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [451] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [452] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(195), }, { /* [453] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [454] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [455] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [456] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(195), }, { /* [457] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [458] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [459] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [460] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(205), }, { /* [461] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [462] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [463] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [464] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(205), }, { /* [465] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [466] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [467] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [468] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(215), }, { /* [469] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(220), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [470] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [471] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [472] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(215), }, { /* [473] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [474] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [475] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [476] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(225), }, { /* [477] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(120), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [478] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [479] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [480] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(105), }, { /* [481] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(120), + /* matcher_indices */ MatcherIndicesIndex(1122), }, { /* [482] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [483] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [484] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(125), }, { /* [485] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [486] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [487] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [488] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(125), }, { /* [489] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [490] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [491] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [492] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(175), + }, + { + /* [493] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), + }, + { + /* [494] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [495] */ /* usage */ core::ParameterUsage::kBias, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [493] */ + /* [496] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), - }, - { - /* [494] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), - }, - { - /* [495] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [496] */ - /* usage */ core::ParameterUsage::kConstOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(175), }, { /* [497] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [498] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [499] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [500] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [501] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [502] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [503] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [504] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(44), }, { /* [505] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(100), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [506] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [507] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [508] */ - /* usage */ core::ParameterUsage::kConstOffset, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(105), }, { /* [509] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(160), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [510] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [511] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [512] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(105), }, { /* [513] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [514] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [515] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kConstOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [516] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(165), }, { /* [517] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [518] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [519] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [520] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(175), }, { /* [521] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), + /* matcher_indices */ MatcherIndicesIndex(1122), }, { /* [522] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [523] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [524] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(185), }, { /* [525] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(190), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [526] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [527] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [528] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(185), }, { /* [529] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(190), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [530] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [531] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [532] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(195), }, { /* [533] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [534] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [535] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [536] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(195), }, { /* [537] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(210), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [538] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [539] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [540] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(215), }, { /* [541] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(220), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [542] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [543] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [544] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(215), }, { /* [545] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(230), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [546] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1100), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [547] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [548] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(225), }, { /* [549] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(250), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [550] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [551] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [552] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(235), }, { /* [553] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(250), + /* matcher_indices */ MatcherIndicesIndex(1128), }, { /* [554] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [555] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [556] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(255), }, { /* [557] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(240), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [558] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [559] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [560] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(255), }, { /* [561] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(240), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [562] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [563] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [564] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(245), }, { /* [565] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(260), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [566] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [567] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [568] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(245), }, { /* [569] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [570] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [571] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [572] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(265), }, { /* [573] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(170), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [574] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [575] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [576] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(175), }, { /* [577] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(230), + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [578] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1142), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [579] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [580] */ - /* usage */ core::ParameterUsage::kLod, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(2), + /* matcher_indices */ MatcherIndicesIndex(175), }, { /* [581] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(230), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [582] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [583] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [584] */ /* usage */ core::ParameterUsage::kLod, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(2), }, { - /* [585] */ + /* [584] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(731), + /* matcher_indices */ MatcherIndicesIndex(235), + }, + { + /* [585] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(753), }, { /* [586] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [587] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [588] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(235), }, { /* [589] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(740), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [590] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [591] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kLod, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(2), }, { /* [592] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(745), }, { /* [593] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(749), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [594] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [595] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1154), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [596] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(755), }, { /* [597] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(758), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [598] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [599] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1154), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [600] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(765), }, { /* [601] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(767), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [602] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1171), }, { /* [603] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1156), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [604] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(775), }, { /* [605] */ - /* usage */ core::ParameterUsage::kImage, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(776), - }, - { - /* [606] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(8), }, { - /* [607] */ + /* [606] */ /* usage */ core::ParameterUsage::kTexel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1156), + /* matcher_indices */ MatcherIndicesIndex(1171), + }, + { + /* [607] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [608] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [609] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(785), }, { - /* [610] */ + /* [609] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(8), + }, + { + /* [610] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1173), }, { /* [611] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [612] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [613] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(794), }, { - /* [614] */ + /* [613] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(8), + }, + { + /* [614] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1173), }, { /* [615] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1154), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [616] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [617] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(803), }, { - /* [618] */ + /* [617] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [618] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [619] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1156), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [620] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [621] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(812), }, { - /* [622] */ + /* [621] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [622] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1171), }, { /* [623] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [624] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [625] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(821), }, { - /* [626] */ + /* [625] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(42), + }, + { + /* [626] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1173), }, { /* [627] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1154), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [628] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [629] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(830), }, { - /* [630] */ + /* [629] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(773), + }, + { + /* [630] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [631] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1156), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [632] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [633] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(839), }, { - /* [634] */ + /* [633] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(773), + }, + { + /* [634] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1171), }, { /* [635] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1136), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [636] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [637] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(848), }, { - /* [638] */ + /* [637] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(773), + }, + { + /* [638] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1173), }, { /* [639] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1154), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [640] */ - /* usage */ core::ParameterUsage::kImageOperands, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [641] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(857), }, { - /* [642] */ + /* [641] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(773), + }, + { + /* [642] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1167), }, { /* [643] */ - /* usage */ core::ParameterUsage::kTexel, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1156), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [644] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(866), }, { /* [645] */ - /* usage */ core::ParameterUsage::kBase, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(773), }, { /* [646] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1171), + }, + { + /* [647] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [648] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(875), + }, + { + /* [649] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(773), + }, + { + /* [650] */ + /* usage */ core::ParameterUsage::kTexel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1173), + }, + { + /* [651] */ + /* usage */ core::ParameterUsage::kImageOperands, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [652] */ + /* usage */ core::ParameterUsage::kBase, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(8), + }, + { + /* [653] */ /* usage */ core::ParameterUsage::kInsert, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(8), }, - { - /* [647] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), - }, - { - /* [648] */ - /* usage */ core::ParameterUsage::kCount, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), - }, - { - /* [649] */ - /* usage */ core::ParameterUsage::kBase, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), - }, - { - /* [650] */ - /* usage */ core::ParameterUsage::kInsert, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), - }, - { - /* [651] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), - }, - { - /* [652] */ - /* usage */ core::ParameterUsage::kCount, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), - }, - { - /* [653] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1067), - }, { /* [654] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [655] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kCount, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [656] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kBase, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [657] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kInsert, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1071), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [658] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [659] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kCount, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(54), }, { /* [660] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1091), }, { /* [661] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1075), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [662] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [663] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [664] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1095), }, { /* [665] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1011), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [666] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1016), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [667] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1006), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [668] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1099), }, { /* [669] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1035), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [670] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [671] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [672] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(290), + /* matcher_indices */ MatcherIndicesIndex(1035), }, { /* [673] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(1040), }, { /* [674] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1030), }, { /* [675] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(41), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [676] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(295), }, { /* [677] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [678] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(61), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [679] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(45), }, { /* [680] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [681] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(201), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [682] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1148), + /* matcher_indices */ MatcherIndicesIndex(66), }, { /* [683] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [684] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(299), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [685] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1146), + /* matcher_indices */ MatcherIndicesIndex(206), }, { /* [686] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(763), }, { /* [687] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(101), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [688] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(304), }, { /* [689] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(31), }, { /* [690] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(121), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [691] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1152), + /* matcher_indices */ MatcherIndicesIndex(106), }, { /* [692] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [693] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(308), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [694] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1150), + /* matcher_indices */ MatcherIndicesIndex(126), }, { /* [695] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(773), }, { /* [696] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(587), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [697] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(313), }, { /* [698] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(42), }, { /* [699] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(596), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [700] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(592), }, { /* [701] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [702] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(605), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [703] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(601), }, { /* [704] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [705] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(614), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [706] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(610), }, { /* [707] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [708] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(623), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [709] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(619), }, { /* [710] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [711] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(632), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [712] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(628), }, { /* [713] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [714] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(641), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [715] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), + /* matcher_indices */ MatcherIndicesIndex(637), }, { /* [716] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [717] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(650), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [718] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), + /* matcher_indices */ MatcherIndicesIndex(646), }, { /* [719] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(20), }, { /* [720] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(659), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [721] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), + /* matcher_indices */ MatcherIndicesIndex(655), }, { /* [722] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(20), }, { /* [723] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(668), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [724] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1158), + /* matcher_indices */ MatcherIndicesIndex(664), }, { /* [725] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(20), }, { /* [726] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(677), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [727] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1158), + /* matcher_indices */ MatcherIndicesIndex(673), }, { /* [728] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(783), }, { /* [729] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(686), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [730] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1158), + /* matcher_indices */ MatcherIndicesIndex(682), }, { /* [731] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(783), }, { /* [732] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(695), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [733] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1158), + /* matcher_indices */ MatcherIndicesIndex(691), }, { /* [734] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(783), }, { /* [735] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(704), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [736] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1158), + /* matcher_indices */ MatcherIndicesIndex(700), }, { /* [737] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(783), }, { /* [738] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(713), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [739] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1158), + /* matcher_indices */ MatcherIndicesIndex(709), }, { /* [740] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(783), }, { /* [741] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(160), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [742] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1094), + /* matcher_indices */ MatcherIndicesIndex(718), }, { /* [743] */ - /* usage */ core::ParameterUsage::kImageOperands, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(783), }, { /* [744] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [745] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(165), }, { /* [746] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1122), }, { /* [747] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImageOperands, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1108), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [748] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(1016), }, { /* [749] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [750] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1130), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [751] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1106), + /* matcher_indices */ MatcherIndicesIndex(1016), }, { /* [752] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [753] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [754] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1121), + /* matcher_indices */ MatcherIndicesIndex(1158), }, { /* [755] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1124), + /* matcher_indices */ MatcherIndicesIndex(1134), }, { /* [756] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1127), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [757] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [758] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(1149), }, { /* [759] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1152), }, { /* [760] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(1155), }, { /* [761] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [762] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [763] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1051), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [764] */ - /* usage */ core::ParameterUsage::kBase, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [765] */ - /* usage */ core::ParameterUsage::kOffset, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [766] */ - /* usage */ core::ParameterUsage::kCount, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [767] */ - /* usage */ core::ParameterUsage::kBase, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(1075), }, { /* [768] */ - /* usage */ core::ParameterUsage::kOffset, + /* usage */ core::ParameterUsage::kBase, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [769] */ - /* usage */ core::ParameterUsage::kCount, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [770] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kCount, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [771] */ - /* usage */ core::ParameterUsage::kE, + /* usage */ core::ParameterUsage::kBase, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [772] */ - /* usage */ core::ParameterUsage::kId, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [773] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kCount, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(54), }, { /* [774] */ - /* usage */ core::ParameterUsage::kE, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [775] */ - /* usage */ core::ParameterUsage::kId, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [776] */ - /* usage */ core::ParameterUsage::kScope, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kId, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [777] */ - /* usage */ core::ParameterUsage::kE, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [778] */ - /* usage */ core::ParameterUsage::kDir, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [779] */ - /* usage */ core::ParameterUsage::kScope, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kId, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [780] */ - /* usage */ core::ParameterUsage::kE, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [781] */ - /* usage */ core::ParameterUsage::kDir, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [782] */ - /* usage */ core::ParameterUsage::kScope, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kDir, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [783] */ - /* usage */ core::ParameterUsage::kValue, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [784] */ - /* usage */ core::ParameterUsage::kId, + /* usage */ core::ParameterUsage::kE, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [785] */ - /* usage */ core::ParameterUsage::kScope, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* usage */ core::ParameterUsage::kDir, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [786] */ - /* usage */ core::ParameterUsage::kValue, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [787] */ - /* usage */ core::ParameterUsage::kId, + /* usage */ core::ParameterUsage::kValue, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [788] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kId, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [789] */ - /* usage */ core::ParameterUsage::kValue, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [790] */ - /* usage */ core::ParameterUsage::kMask, + /* usage */ core::ParameterUsage::kValue, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [791] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kId, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [792] */ - /* usage */ core::ParameterUsage::kValue, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [793] */ - /* usage */ core::ParameterUsage::kMask, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [794] */ - /* usage */ core::ParameterUsage::kScope, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), - }, - { - /* [795] */ /* usage */ core::ParameterUsage::kValue, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(8), }, { - /* [796] */ - /* usage */ core::ParameterUsage::kDelta, + /* [794] */ + /* usage */ core::ParameterUsage::kMask, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), + }, + { + /* [795] */ + /* usage */ core::ParameterUsage::kScope, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(629), + }, + { + /* [796] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [797] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kMask, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [798] */ - /* usage */ core::ParameterUsage::kValue, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [799] */ - /* usage */ core::ParameterUsage::kDelta, + /* usage */ core::ParameterUsage::kValue, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [800] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kDelta, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [801] */ - /* usage */ core::ParameterUsage::kGroupOperation, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [802] */ /* usage */ core::ParameterUsage::kValue, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [803] */ - /* usage */ core::ParameterUsage::kScope, + /* usage */ core::ParameterUsage::kDelta, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [804] */ - /* usage */ core::ParameterUsage::kGroupOperation, + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(624), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [805] */ - /* usage */ core::ParameterUsage::kValue, + /* usage */ core::ParameterUsage::kGroupOperation, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1091), + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [806] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1031), - }, - { - /* [807] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kValue, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(8), }, { - /* [808] */ - /* usage */ core::ParameterUsage::kImage, + /* [807] */ + /* usage */ core::ParameterUsage::kScope, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(470), + /* matcher_indices */ MatcherIndicesIndex(629), + }, + { + /* [808] */ + /* usage */ core::ParameterUsage::kGroupOperation, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(629), }, { /* [809] */ - /* usage */ core::ParameterUsage::kLevel, + /* usage */ core::ParameterUsage::kValue, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(1119), }, { /* [810] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(479), + /* matcher_indices */ MatcherIndicesIndex(1055), }, { /* [811] */ - /* usage */ core::ParameterUsage::kLevel, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(5), }, { /* [812] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(488), + /* matcher_indices */ MatcherIndicesIndex(475), }, { /* [813] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [814] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(497), + /* matcher_indices */ MatcherIndicesIndex(484), }, { /* [815] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [816] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(506), + /* matcher_indices */ MatcherIndicesIndex(493), }, { /* [817] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [818] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), + /* matcher_indices */ MatcherIndicesIndex(502), }, { /* [819] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [820] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(524), + /* matcher_indices */ MatcherIndicesIndex(511), }, { /* [821] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(48), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [822] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(533), + /* matcher_indices */ MatcherIndicesIndex(520), }, { /* [823] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [824] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(542), + /* matcher_indices */ MatcherIndicesIndex(529), }, { /* [825] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(21), }, { /* [826] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(551), + /* matcher_indices */ MatcherIndicesIndex(538), }, { /* [827] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [828] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(560), + /* matcher_indices */ MatcherIndicesIndex(547), }, { /* [829] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(108), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [830] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(722), + /* matcher_indices */ MatcherIndicesIndex(556), }, { /* [831] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1140), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [832] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1047), + /* matcher_indices */ MatcherIndicesIndex(565), }, { /* [833] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1051), + /* matcher_indices */ MatcherIndicesIndex(32), }, { /* [834] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1055), + /* matcher_indices */ MatcherIndicesIndex(727), }, { /* [835] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(20), }, { /* [836] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1055), + /* matcher_indices */ MatcherIndicesIndex(1071), }, { /* [837] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(1075), }, { /* [838] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1103), + /* matcher_indices */ MatcherIndicesIndex(1079), }, { /* [839] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(982), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [840] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1112), + /* matcher_indices */ MatcherIndicesIndex(1079), }, { /* [841] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1115), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [842] */ - /* usage */ core::ParameterUsage::kX, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(8), + /* matcher_indices */ MatcherIndicesIndex(1131), }, { /* [843] */ - /* usage */ core::ParameterUsage::kI, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1059), + /* matcher_indices */ MatcherIndicesIndex(1000), }, { /* [844] */ - /* usage */ core::ParameterUsage::kX, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(976), + /* matcher_indices */ MatcherIndicesIndex(1140), }, { /* [845] */ - /* usage */ core::ParameterUsage::kI, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(974), + /* matcher_indices */ MatcherIndicesIndex(1143), }, { /* [846] */ @@ -7780,169 +7763,217 @@ constexpr ParameterInfo kParameters[] = { /* [847] */ /* usage */ core::ParameterUsage::kI, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1063), + /* matcher_indices */ MatcherIndicesIndex(1083), }, { /* [848] */ /* usage */ core::ParameterUsage::kX, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1103), + /* matcher_indices */ MatcherIndicesIndex(994), }, { /* [849] */ /* usage */ core::ParameterUsage::kI, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(980), + /* matcher_indices */ MatcherIndicesIndex(992), }, { /* [850] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kX, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1001), + /* matcher_indices */ MatcherIndicesIndex(8), }, { /* [851] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kI, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1001), + /* matcher_indices */ MatcherIndicesIndex(1087), }, { /* [852] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kX, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1021), + /* matcher_indices */ MatcherIndicesIndex(1131), }, { /* [853] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kI, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1021), + /* matcher_indices */ MatcherIndicesIndex(998), }, { /* [854] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1026), + /* matcher_indices */ MatcherIndicesIndex(1004), }, { /* [855] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1026), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [856] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(353), + /* matcher_indices */ MatcherIndicesIndex(1115), }, { /* [857] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(362), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [858] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(371), + /* matcher_indices */ MatcherIndicesIndex(1025), }, { /* [859] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(380), + /* matcher_indices */ MatcherIndicesIndex(1025), }, { /* [860] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(389), + /* matcher_indices */ MatcherIndicesIndex(1045), }, { /* [861] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(398), + /* matcher_indices */ MatcherIndicesIndex(1045), }, { /* [862] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(407), + /* matcher_indices */ MatcherIndicesIndex(1050), }, { /* [863] */ - /* usage */ core::ParameterUsage::kImage, + /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(416), + /* matcher_indices */ MatcherIndicesIndex(1050), }, { /* [864] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), + /* matcher_indices */ MatcherIndicesIndex(358), }, { /* [865] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(434), + /* matcher_indices */ MatcherIndicesIndex(367), }, { /* [866] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(443), + /* matcher_indices */ MatcherIndicesIndex(376), }, { /* [867] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(452), + /* matcher_indices */ MatcherIndicesIndex(385), }, { /* [868] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), + /* matcher_indices */ MatcherIndicesIndex(394), }, { /* [869] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(569), + /* matcher_indices */ MatcherIndicesIndex(403), }, { /* [870] */ /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(578), + /* matcher_indices */ MatcherIndicesIndex(412), }, { /* [871] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1162), + /* matcher_indices */ MatcherIndicesIndex(421), }, { /* [872] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1166), + /* matcher_indices */ MatcherIndicesIndex(430), }, { /* [873] */ - /* usage */ core::ParameterUsage::kNone, + /* usage */ core::ParameterUsage::kImage, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1168), + /* matcher_indices */ MatcherIndicesIndex(439), }, { /* [874] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(448), + }, + { + /* [875] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(457), + }, + { + /* [876] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), + }, + { + /* [877] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(574), + }, + { + /* [878] */ + /* usage */ core::ParameterUsage::kImage, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(583), + }, + { + /* [879] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(1170), + /* matcher_indices */ MatcherIndicesIndex(1177), + }, + { + /* [880] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1179), + }, + { + /* [881] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1181), + }, + { + /* [882] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(1183), }, }; @@ -7953,13 +7984,13 @@ constexpr TemplateInfo kTemplates[] = { { /* [0] */ /* name */ "Z", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [1] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* matcher_indices */ MatcherIndicesIndex(1188), /* kind */ TemplateInfo::Kind::kType, }, { @@ -7984,25 +8015,25 @@ constexpr TemplateInfo kTemplates[] = { /* [5] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [6] */ /* name */ "A", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [7] */ /* name */ "Z", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [8] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [9] */ @@ -8013,223 +8044,223 @@ constexpr TemplateInfo kTemplates[] = { { /* [10] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), + /* matcher_indices */ MatcherIndicesIndex(1187), /* kind */ TemplateInfo::Kind::kType, }, { /* [11] */ /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [12] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1020), /* kind */ TemplateInfo::Kind::kType, }, { /* [13] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [14] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1191), /* kind */ TemplateInfo::Kind::kType, }, { /* [15] */ - /* name */ "S", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [16] */ - /* name */ "F", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [17] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [18] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [19] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* matcher_indices */ MatcherIndicesIndex(1020), /* kind */ TemplateInfo::Kind::kType, }, { /* [20] */ - /* name */ "S", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [21] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(792), + /* kind */ TemplateInfo::Kind::kType, }, { /* [22] */ - /* name */ "A", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [23] */ /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [24] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [25] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [26] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1020), + /* kind */ TemplateInfo::Kind::kType, }, { /* [27] */ - /* name */ "A", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [28] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1014), /* kind */ TemplateInfo::Kind::kType, }, { /* [29] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [30] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [31] */ - /* name */ "V", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [32] */ - /* name */ "N", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [30] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [31] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [32] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, + }, { /* [33] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1173), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [34] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(996), + /* matcher_indices */ MatcherIndicesIndex(1188), /* kind */ TemplateInfo::Kind::kType, }, { /* [35] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, }, { /* [36] */ /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1007), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [37] */ - /* name */ "C", + /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [38] */ - /* name */ "R", + /* name */ "A", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [39] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(996), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [40] */ - /* name */ "K", + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1191), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [41] */ + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [41] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(992), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [42] */ - /* name */ "C", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [43] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [44] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(996), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [45] */ /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [46] */ /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1028), + /* matcher_indices */ MatcherIndicesIndex(792), /* kind */ TemplateInfo::Kind::kType, }, { @@ -8246,994 +8277,1174 @@ constexpr TemplateInfo kTemplates[] = { }, { /* [49] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1174), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [50] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(359), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [51] */ - /* name */ "C", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [52] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1014), + /* kind */ TemplateInfo::Kind::kType, }, { /* [53] */ - /* name */ "K", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [54] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1007), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [55] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [56] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [55] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [56] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, + }, { /* [57] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(2), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [58] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(2), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), /* kind */ TemplateInfo::Kind::kType, }, { /* [59] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [60] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [61] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [62] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [63] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [64] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [65] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [66] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [67] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [68] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [69] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1175), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [70] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(1176), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [71] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [72] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [73] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [74] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [75] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [76] */ - /* name */ "Z", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [77] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [78] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [79] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [80] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(9), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [81] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [82] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [83] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [84] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [85] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [86] */ /* name */ "S", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [87] */ + /* [60] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [61] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [62] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [63] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [64] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [65] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [66] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [67] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [68] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [69] */ + /* name */ "Z", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [70] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [71] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [72] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [73] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [74] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [75] */ + /* name */ "V", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [76] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [77] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1190), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [78] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [79] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [80] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [81] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(611), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [82] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [83] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [84] */ + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [85] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [86] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [87] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [88] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(2), + /* kind */ TemplateInfo::Kind::kType, }, { /* [89] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(2), /* kind */ TemplateInfo::Kind::kType, }, { /* [90] */ - /* name */ "Z", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [91] */ - /* name */ "F", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [92] */ - /* name */ "N", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [93] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [94] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(624), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [95] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1028), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [96] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(920), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [97] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [98] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1172), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1192), /* kind */ TemplateInfo::Kind::kType, }, { /* [99] */ - /* name */ "F", + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(1193), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [100] */ + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [100] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(920), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [101] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(2), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [102] */ /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(994), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [103] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, }, { /* [104] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(929), + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(629), /* kind */ TemplateInfo::Kind::kType, }, { /* [105] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [106] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1172), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [107] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, }, { /* [108] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(929), + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(629), /* kind */ TemplateInfo::Kind::kType, }, { /* [109] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(2), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1186), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [110] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(994), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [111] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [112] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(938), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [113] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* name */ "Z", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [114] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1172), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [115] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [116] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(938), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [117] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(2), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [118] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(994), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, }, { /* [119] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [120] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(947), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [121] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [122] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1172), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [123] */ - /* name */ "F", + /* name */ "S", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [124] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(947), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [125] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(2), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [126] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(994), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [127] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [128] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), + /* matcher_indices */ MatcherIndicesIndex(1188), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [127] */ + /* name */ "Z", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [128] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, { /* [129] */ - /* name */ "K", + /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [130] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, }, { /* [131] */ - /* name */ "R", + /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [132] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "OT", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [133] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "CT", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [134] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(938), /* kind */ TemplateInfo::Kind::kType, }, { /* [135] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [136] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1189), /* kind */ TemplateInfo::Kind::kType, }, { /* [137] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [138] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(947), + /* kind */ TemplateInfo::Kind::kType, }, { /* [139] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1138), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [140] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1189), /* kind */ TemplateInfo::Kind::kType, }, { /* [141] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [142] */ - /* name */ "B", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(956), /* kind */ TemplateInfo::Kind::kType, }, { /* [143] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [144] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1189), /* kind */ TemplateInfo::Kind::kType, }, { /* [145] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [146] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(965), + /* kind */ TemplateInfo::Kind::kType, }, { /* [147] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, }, { /* [148] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1189), /* kind */ TemplateInfo::Kind::kType, }, { /* [149] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [150] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, }, { /* [151] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(738), + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [152] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(9), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [153] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [154] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(756), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [155] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(9), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [156] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [157] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(774), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [158] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(9), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [159] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [160] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [161] */ - /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [162] */ + /* [153] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [154] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [155] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [156] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [157] */ /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [158] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [159] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [160] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(611), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [161] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [162] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, { /* [163] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(866), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [164] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(611), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [165] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [166] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(875), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [167] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, { /* [168] */ - /* name */ "F", + /* name */ "B", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [169] */ + /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [169] */ + /* [170] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [171] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1191), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [172] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [173] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [174] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [175] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [176] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [177] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [178] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [179] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [180] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [181] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(629), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [182] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [183] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [184] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(772), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [185] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [186] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [187] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(792), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [188] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(9), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [189] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [190] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [191] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [192] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [193] */ /* name */ "I", /* matcher_indices */ MatcherIndicesIndex(884), /* kind */ TemplateInfo::Kind::kType, }, { - /* [170] */ + /* [194] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), + /* matcher_indices */ MatcherIndicesIndex(1188), /* kind */ TemplateInfo::Kind::kType, }, { - /* [171] */ + /* [195] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { - /* [172] */ + /* [196] */ /* name */ "I", /* matcher_indices */ MatcherIndicesIndex(893), /* kind */ TemplateInfo::Kind::kType, }, - { - /* [173] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1017), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [174] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [175] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(956), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [176] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1172), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [177] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [178] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(965), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [179] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1172), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [180] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [181] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [182] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [183] */ - /* name */ "M", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [184] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [185] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [186] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [187] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [188] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [189] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1138), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [190] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [191] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [192] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1138), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [193] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [194] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [195] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [196] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(359), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [197] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(1012), + /* matcher_indices */ MatcherIndicesIndex(1188), /* kind */ TemplateInfo::Kind::kType, }, { /* [198] */ - /* name */ "N", + /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [199] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [200] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(1012), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [201] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [202] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(624), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [203] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [204] */ /* name */ "I", /* matcher_indices */ MatcherIndicesIndex(902), /* kind */ TemplateInfo::Kind::kType, }, { - /* [205] */ + /* [200] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [201] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [202] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(911), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [203] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1188), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [204] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [205] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(974), + /* kind */ TemplateInfo::Kind::kType, }, { /* [206] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(911), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(1189), /* kind */ TemplateInfo::Kind::kType, }, { /* [207] */ /* name */ "F", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [208] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(359), + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(983), /* kind */ TemplateInfo::Kind::kType, }, { /* [209] */ /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(1138), - /* kind */ TemplateInfo::Kind::kNumber, + /* matcher_indices */ MatcherIndicesIndex(1189), + /* kind */ TemplateInfo::Kind::kType, }, { /* [210] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(992), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [211] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(606), + /* matcher_indices */ MatcherIndicesIndex(1187), /* kind */ TemplateInfo::Kind::kType, }, { /* [212] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(1028), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [213] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(624), + /* name */ "M", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [214] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [215] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [216] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [217] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [218] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(611), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [219] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(753), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [220] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [221] */ + /* name */ "OT", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [222] */ + /* name */ "CT", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [223] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [224] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [225] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [226] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1187), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [227] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [228] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [229] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [230] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(1185), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [231] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [232] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [233] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [234] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [235] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(920), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [236] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [237] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(929), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [238] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [239] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(792), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [240] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(611), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [241] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(1014), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [242] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(629), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [243] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, }; static_assert(TemplateIndex::CanIndex(kTemplates), @@ -9246,9 +9457,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(509), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9257,9 +9468,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(741), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(745), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9268,9 +9479,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(164), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9279,9 +9490,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(428), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9290,9 +9501,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 4, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(117), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(119), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9301,9 +9512,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 4, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(425), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(432), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9312,9 +9523,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(172), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(174), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9323,9 +9534,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(177), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9334,9 +9545,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(429), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(436), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9345,9 +9556,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(433), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(440), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9356,9 +9567,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(437), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(444), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9367,9 +9578,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(441), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(448), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9378,9 +9589,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(122), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(124), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9389,9 +9600,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(127), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(129), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9400,9 +9611,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(192), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(194), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9411,9 +9622,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(197), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(199), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9422,9 +9633,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(445), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(452), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9433,9 +9644,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(449), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(456), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9444,9 +9655,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(134), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9455,9 +9666,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(137), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9466,9 +9677,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(453), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(460), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9477,9 +9688,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(457), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(464), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9488,9 +9699,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(212), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(214), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9499,9 +9710,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(217), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9510,9 +9721,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(461), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9521,9 +9732,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(465), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(472), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9532,9 +9743,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(222), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(224), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9543,9 +9754,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(469), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(476), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9555,8 +9766,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(8), - /* parameters */ ParameterIndex(545), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(552), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9566,8 +9777,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 3, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(473), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(480), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9577,8 +9788,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(557), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(564), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9588,8 +9799,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(561), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(568), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9599,8 +9810,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(549), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(556), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9610,8 +9821,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(553), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(560), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9621,8 +9832,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(477), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(484), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9632,8 +9843,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(481), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(488), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9643,8 +9854,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(565), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(572), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9653,9 +9864,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(509), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9664,9 +9875,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(513), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(520), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9675,9 +9886,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(164), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9686,9 +9897,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 4, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(167), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(169), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9697,9 +9908,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 4, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(15), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9708,9 +9919,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(517), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(524), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9719,9 +9930,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(521), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9730,9 +9941,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(172), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(174), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9741,9 +9952,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(177), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9752,9 +9963,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(182), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(184), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9763,9 +9974,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(187), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(189), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9774,9 +9985,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(21), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(23), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9785,9 +9996,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(27), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(29), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9796,9 +10007,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(525), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(532), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9807,9 +10018,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(529), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(536), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9818,9 +10029,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(192), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(194), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9829,9 +10040,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(197), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(199), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9840,9 +10051,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(202), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(204), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9851,9 +10062,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(207), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(209), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9862,9 +10073,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(33), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(35), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9873,9 +10084,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(39), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(41), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9884,9 +10095,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(533), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(540), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9895,9 +10106,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(537), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(544), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9906,9 +10117,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(212), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(214), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9917,9 +10128,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(217), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9928,9 +10139,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(541), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(548), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9939,9 +10150,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(222), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(224), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9951,8 +10162,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(8), - /* parameters */ ParameterIndex(545), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(552), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9962,8 +10173,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 3, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(227), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(229), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9973,8 +10184,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(549), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(556), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9984,8 +10195,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(553), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(560), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -9995,8 +10206,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(232), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(234), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10006,8 +10217,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(237), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(239), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10017,8 +10228,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(557), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(564), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10028,8 +10239,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(561), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(568), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10039,8 +10250,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(565), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(572), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10049,9 +10260,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(741), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(181), + /* parameters */ ParameterIndex(700), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10059,10 +10270,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(242), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(181), + /* parameters */ ParameterIndex(703), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10070,76 +10281,76 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(247), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(184), + /* parameters */ ParameterIndex(706), + /* return_matcher_indices */ MatcherIndicesIndex(1171), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [76] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(485), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(184), + /* parameters */ ParameterIndex(709), + /* return_matcher_indices */ MatcherIndicesIndex(1171), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [77] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(489), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(187), + /* parameters */ ParameterIndex(712), + /* return_matcher_indices */ MatcherIndicesIndex(1173), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [78] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(142), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(187), + /* parameters */ ParameterIndex(715), + /* return_matcher_indices */ MatcherIndicesIndex(1173), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [79] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(147), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(181), + /* parameters */ ParameterIndex(718), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [80] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(493), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(184), + /* parameters */ ParameterIndex(721), + /* return_matcher_indices */ MatcherIndicesIndex(1171), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [81] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(497), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(187), + /* parameters */ ParameterIndex(724), + /* return_matcher_indices */ MatcherIndicesIndex(1173), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10147,43 +10358,43 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(197), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(181), + /* parameters */ ParameterIndex(727), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [83] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(449), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(184), + /* parameters */ ParameterIndex(730), + /* return_matcher_indices */ MatcherIndicesIndex(1171), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [84] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(137), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(187), + /* parameters */ ParameterIndex(733), + /* return_matcher_indices */ MatcherIndicesIndex(1173), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [85] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(457), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(181), + /* parameters */ ParameterIndex(736), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10191,10 +10402,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(577), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(184), + /* parameters */ ParameterIndex(739), + /* return_matcher_indices */ MatcherIndicesIndex(1171), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10202,21 +10413,21 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(581), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(187), + /* parameters */ ParameterIndex(742), + /* return_matcher_indices */ MatcherIndicesIndex(1173), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [88] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(501), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 4, + /* templates */ TemplateIndex(114), + /* parameters */ ParameterIndex(834), + /* return_matcher_indices */ MatcherIndicesIndex(1175), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10224,65 +10435,65 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(505), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 5, + /* templates */ TemplateIndex(67), + /* parameters */ ParameterIndex(424), + /* return_matcher_indices */ MatcherIndicesIndex(1175), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [90] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(569), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(190), + /* parameters */ ParameterIndex(745), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [91] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(573), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(244), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [92] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(242), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(249), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [93] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(247), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(492), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [94] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(252), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(496), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10291,31 +10502,31 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(257), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [96] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(45), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(149), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [97] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(51), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(500), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10323,43 +10534,43 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(529), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(504), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [99] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(197), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(199), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [100] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(207), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(456), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [101] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(89), - /* parameters */ ParameterIndex(39), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10367,142 +10578,142 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(82), - /* parameters */ ParameterIndex(537), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(464), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [103] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(577), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(584), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [104] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(581), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(588), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [105] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(262), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(508), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [106] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(267), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* parameters */ ParameterIndex(512), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [107] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(672), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(576), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [108] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(675), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(580), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [109] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(678), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(244), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [110] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(681), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(249), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [111] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(684), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(254), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [112] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(687), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(259), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [113] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(690), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(47), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [114] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(693), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(53), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10510,43 +10721,43 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(357), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(536), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [116] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(361), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(199), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [117] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(365), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(209), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [118] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(369), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 3, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(41), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10554,10 +10765,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(373), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 2, + /* templates */ TemplateIndex(119), + /* parameters */ ParameterIndex(544), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10565,10 +10776,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(75), - /* parameters */ ParameterIndex(377), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(584), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10576,32 +10787,32 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(75), - /* parameters */ ParameterIndex(381), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(588), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [122] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(75), - /* parameters */ ParameterIndex(385), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(264), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [123] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(151), - /* parameters */ ParameterIndex(696), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(269), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10610,9 +10821,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(151), - /* parameters */ ParameterIndex(699), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(676), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10621,9 +10832,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(154), - /* parameters */ ParameterIndex(702), - /* return_matcher_indices */ MatcherIndicesIndex(1154), + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(679), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10632,9 +10843,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(154), - /* parameters */ ParameterIndex(705), - /* return_matcher_indices */ MatcherIndicesIndex(1154), + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(682), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10643,9 +10854,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(708), - /* return_matcher_indices */ MatcherIndicesIndex(1156), + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(685), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10654,9 +10865,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(711), - /* return_matcher_indices */ MatcherIndicesIndex(1156), + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(688), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10664,10 +10875,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(151), - /* parameters */ ParameterIndex(714), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(691), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10675,10 +10886,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(154), - /* parameters */ ParameterIndex(717), - /* return_matcher_indices */ MatcherIndicesIndex(1154), + /* num_templates */ 2, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(694), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10686,87 +10897,87 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(720), - /* return_matcher_indices */ MatcherIndicesIndex(1156), + /* num_templates */ 2, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(697), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [132] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(151), - /* parameters */ ParameterIndex(723), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(360), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [133] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(154), - /* parameters */ ParameterIndex(726), - /* return_matcher_indices */ MatcherIndicesIndex(1154), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(364), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [134] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(729), - /* return_matcher_indices */ MatcherIndicesIndex(1156), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(368), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [135] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(151), - /* parameters */ ParameterIndex(732), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(372), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [136] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(154), - /* parameters */ ParameterIndex(735), - /* return_matcher_indices */ MatcherIndicesIndex(1154), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(376), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [137] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(738), - /* return_matcher_indices */ MatcherIndicesIndex(1156), + /* templates */ TemplateIndex(112), + /* parameters */ ParameterIndex(380), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [138] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(77), - /* parameters */ ParameterIndex(830), - /* return_matcher_indices */ MatcherIndicesIndex(1160), + /* num_templates */ 3, + /* templates */ TemplateIndex(112), + /* parameters */ ParameterIndex(384), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10775,9 +10986,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(585), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* templates */ TemplateIndex(112), + /* parameters */ ParameterIndex(388), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10786,8 +10997,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(589), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(592), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10797,8 +11008,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(593), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(596), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10808,8 +11019,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(597), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(600), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10819,8 +11030,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(601), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(604), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10830,8 +11041,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(605), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(608), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10841,8 +11052,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(609), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(612), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10852,8 +11063,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(613), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(616), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10863,8 +11074,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(617), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(620), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10874,8 +11085,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(621), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(624), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10885,8 +11096,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(625), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(628), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10896,8 +11107,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(629), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(632), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10907,8 +11118,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(633), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(636), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10918,8 +11129,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(637), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(640), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10929,20 +11140,20 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(641), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(644), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [154] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(856), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(648), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10951,8 +11162,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(857), + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(864), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -10962,9 +11173,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(858), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(865), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10973,9 +11184,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(859), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(866), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10984,9 +11195,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(860), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(867), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -10995,9 +11206,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(861), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(868), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11006,9 +11217,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 4, - /* templates */ TemplateIndex(81), - /* parameters */ ParameterIndex(862), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(869), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11016,10 +11227,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(863), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* num_templates */ 4, + /* templates */ TemplateIndex(118), + /* parameters */ ParameterIndex(870), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11027,10 +11238,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(148), - /* parameters */ ParameterIndex(864), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* num_templates */ 5, + /* templates */ TemplateIndex(57), + /* parameters */ ParameterIndex(871), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11039,9 +11250,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(148), - /* parameters */ ParameterIndex(865), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(178), + /* parameters */ ParameterIndex(872), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11050,9 +11261,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(148), - /* parameters */ ParameterIndex(866), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* templates */ TemplateIndex(178), + /* parameters */ ParameterIndex(873), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11061,9 +11272,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(148), - /* parameters */ ParameterIndex(867), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(178), + /* parameters */ ParameterIndex(874), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11071,65 +11282,65 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(85), - /* parameters */ ParameterIndex(868), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* num_templates */ 3, + /* templates */ TemplateIndex(178), + /* parameters */ ParameterIndex(875), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [167] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(389), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(122), + /* parameters */ ParameterIndex(876), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [168] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(97), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 3, + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(392), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [169] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(393), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(99), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [170] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(74), - /* parameters */ ParameterIndex(102), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 3, + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(396), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [171] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(397), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* num_templates */ 4, + /* templates */ TemplateIndex(111), + /* parameters */ ParameterIndex(104), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11138,9 +11349,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(144), - /* parameters */ ParameterIndex(401), - /* return_matcher_indices */ MatcherIndicesIndex(1144), + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(400), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11148,54 +11359,54 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(405), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(404), + /* return_matcher_indices */ MatcherIndicesIndex(1169), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [174] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(75), - /* parameters */ ParameterIndex(107), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(408), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [175] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(409), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(112), + /* parameters */ ParameterIndex(109), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [176] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(75), - /* parameters */ ParameterIndex(112), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 2, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(412), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [177] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(413), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_templates */ 3, + /* templates */ TemplateIndex(112), + /* parameters */ ParameterIndex(114), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11204,20 +11415,20 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(417), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(416), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [179] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(808), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(175), + /* parameters */ ParameterIndex(420), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11226,8 +11437,8 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(810), + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(812), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -11237,9 +11448,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(812), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(814), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11248,9 +11459,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(814), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(816), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11259,9 +11470,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(816), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(818), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11270,9 +11481,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(818), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(820), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11281,9 +11492,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(820), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(822), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11291,10 +11502,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(822), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* num_templates */ 6, + /* templates */ TemplateIndex(33), + /* parameters */ ParameterIndex(824), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11303,9 +11514,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 5, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(824), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(62), + /* parameters */ ParameterIndex(826), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11314,9 +11525,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 5, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(1150), + /* templates */ TemplateIndex(62), + /* parameters */ ParameterIndex(828), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11325,9 +11536,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 5, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(828), - /* return_matcher_indices */ MatcherIndicesIndex(1152), + /* templates */ TemplateIndex(62), + /* parameters */ ParameterIndex(830), + /* return_matcher_indices */ MatcherIndicesIndex(42), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11335,241 +11546,241 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(6), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_templates */ 5, + /* templates */ TemplateIndex(62), + /* parameters */ ParameterIndex(832), + /* return_matcher_indices */ MatcherIndicesIndex(773), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [191] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(13), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(8), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [192] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(6), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(284), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [193] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(13), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [194] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(6), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(309), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [195] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(13), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(289), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [196] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(6), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(294), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [197] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(13), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [198] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(175), - /* parameters */ ParameterIndex(345), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(319), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [199] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(345), - /* return_matcher_indices */ MatcherIndicesIndex(1162), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(324), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [200] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(8), - /* parameters */ ParameterIndex(297), + /* parameters */ ParameterIndex(299), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [201] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 3, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(282), + /* parameters */ ParameterIndex(71), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [202] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(92), + /* parameters */ ParameterIndex(304), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [203] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(307), + /* parameters */ ParameterIndex(309), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [204] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(287), + /* parameters */ ParameterIndex(77), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [205] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(292), + /* parameters */ ParameterIndex(83), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [206] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(312), + /* parameters */ ParameterIndex(314), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [207] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(317), + /* parameters */ ParameterIndex(319), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [208] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(322), + /* parameters */ ParameterIndex(324), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [209] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(8), - /* parameters */ ParameterIndex(297), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [210] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(69), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [211] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(302), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11577,218 +11788,218 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, + /* num_templates */ 3, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(307), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [213] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(75), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(314), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [214] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(81), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(324), + /* return_matcher_indices */ MatcherIndicesIndex(1167), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [215] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(312), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(193), + /* parameters */ ParameterIndex(879), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [216] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(317), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(196), + /* parameters */ ParameterIndex(879), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [217] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(322), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(199), + /* parameters */ ParameterIndex(879), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [218] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(87), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(202), + /* parameters */ ParameterIndex(879), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [219] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(87), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(235), + /* parameters */ ParameterIndex(879), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [220] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(92), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(879), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [221] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(92), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(134), + /* parameters */ ParameterIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(1177), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [222] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(312), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(138), + /* parameters */ ParameterIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(1177), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [223] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(322), - /* return_matcher_indices */ MatcherIndicesIndex(1136), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(142), + /* parameters */ ParameterIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(1177), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [224] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(163), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 4, + /* templates */ TemplateIndex(146), + /* parameters */ ParameterIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(1177), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [225] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(166), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* templates */ TemplateIndex(205), + /* parameters */ ParameterIndex(13), + /* return_matcher_indices */ MatcherIndicesIndex(1177), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [226] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(169), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(13), + /* return_matcher_indices */ MatcherIndicesIndex(1177), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [227] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(172), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(274), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [228] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(204), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(279), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [229] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_parameters */ 5, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(206), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(154), + /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [230] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(272), + /* num_templates */ 2, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(159), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [231] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(277), + /* parameters */ ParameterIndex(274), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -11797,65 +12008,65 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(152), + /* num_templates */ 1, + /* templates */ TemplateIndex(5), + /* parameters */ ParameterIndex(279), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [233] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(157), + /* parameters */ ParameterIndex(59), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [234] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(272), + /* num_templates */ 2, + /* templates */ TemplateIndex(7), + /* parameters */ ParameterIndex(65), /* return_matcher_indices */ MatcherIndicesIndex(2), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [235] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(5), - /* parameters */ ParameterIndex(277), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_templates */ 5, + /* templates */ TemplateIndex(83), + /* parameters */ ParameterIndex(672), + /* return_matcher_indices */ MatcherIndicesIndex(1030), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [236] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(57), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_templates */ 5, + /* templates */ TemplateIndex(88), + /* parameters */ ParameterIndex(672), + /* return_matcher_indices */ MatcherIndicesIndex(1030), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [237] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(63), - /* return_matcher_indices */ MatcherIndicesIndex(2), + /* num_templates */ 5, + /* templates */ TemplateIndex(93), + /* parameters */ ParameterIndex(672), + /* return_matcher_indices */ MatcherIndicesIndex(1030), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -11864,305 +12075,305 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 5, - /* templates */ TemplateIndex(49), - /* parameters */ ParameterIndex(665), - /* return_matcher_indices */ MatcherIndicesIndex(1006), + /* templates */ TemplateIndex(98), + /* parameters */ ParameterIndex(672), + /* return_matcher_indices */ MatcherIndicesIndex(1030), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [239] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(57), - /* parameters */ ParameterIndex(665), - /* return_matcher_indices */ MatcherIndicesIndex(1006), + /* num_templates */ 3, + /* templates */ TemplateIndex(103), + /* parameters */ ParameterIndex(344), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [240] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(64), - /* parameters */ ParameterIndex(665), - /* return_matcher_indices */ MatcherIndicesIndex(1006), + /* num_templates */ 3, + /* templates */ TemplateIndex(103), + /* parameters */ ParameterIndex(352), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [241] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(69), - /* parameters */ ParameterIndex(665), - /* return_matcher_indices */ MatcherIndicesIndex(1006), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [242] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(342), - /* return_matcher_indices */ MatcherIndicesIndex(8), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [243] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(349), - /* return_matcher_indices */ MatcherIndicesIndex(8), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [244] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(353), - /* return_matcher_indices */ MatcherIndicesIndex(994), + /* parameters */ ParameterIndex(356), + /* return_matcher_indices */ MatcherIndicesIndex(772), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [242] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(748), + /* return_matcher_indices */ MatcherIndicesIndex(8), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [243] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(751), + /* return_matcher_indices */ MatcherIndicesIndex(1119), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [244] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(755), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [245] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(744), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(880), + /* return_matcher_indices */ MatcherIndicesIndex(1179), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [246] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(747), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(881), + /* return_matcher_indices */ MatcherIndicesIndex(1181), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [247] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(751), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(882), + /* return_matcher_indices */ MatcherIndicesIndex(1183), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [248] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(872), - /* return_matcher_indices */ MatcherIndicesIndex(1166), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 7, + /* templates */ TemplateIndex(12), + /* parameters */ ParameterIndex(660), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [249] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(873), - /* return_matcher_indices */ MatcherIndicesIndex(1168), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 7, + /* templates */ TemplateIndex(19), + /* parameters */ ParameterIndex(664), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [250] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(874), - /* return_matcher_indices */ MatcherIndicesIndex(1170), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 7, + /* templates */ TemplateIndex(26), + /* parameters */ ParameterIndex(668), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [251] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(34), - /* parameters */ ParameterIndex(653), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 6, + /* templates */ TemplateIndex(39), + /* parameters */ ParameterIndex(329), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [252] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(39), - /* parameters */ ParameterIndex(657), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 6, + /* templates */ TemplateIndex(45), + /* parameters */ ParameterIndex(334), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [253] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(44), - /* parameters */ ParameterIndex(661), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 6, + /* templates */ TemplateIndex(51), + /* parameters */ ParameterIndex(339), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [254] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 4, - /* templates */ TemplateIndex(35), - /* parameters */ ParameterIndex(327), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* templates */ TemplateIndex(170), + /* parameters */ ParameterIndex(858), + /* return_matcher_indices */ MatcherIndicesIndex(1025), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [255] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(40), - /* parameters */ ParameterIndex(332), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(232), + /* parameters */ ParameterIndex(860), + /* return_matcher_indices */ MatcherIndicesIndex(1045), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [256] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(45), - /* parameters */ ParameterIndex(337), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(232), + /* parameters */ ParameterIndex(862), + /* return_matcher_indices */ MatcherIndicesIndex(1050), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [257] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(53), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(1001), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [258] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(61), - /* parameters */ ParameterIndex(852), - /* return_matcher_indices */ MatcherIndicesIndex(1021), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [259] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(61), - /* parameters */ ParameterIndex(854), - /* return_matcher_indices */ MatcherIndicesIndex(1026), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [260] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(93), + /* templates */ TemplateIndex(103), /* parameters */ ParameterIndex(0), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [261] */ + /* [258] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, + /* num_templates */ 4, + /* templates */ TemplateIndex(103), + /* parameters */ ParameterIndex(348), + /* return_matcher_indices */ MatcherIndicesIndex(8), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [259] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(669), + /* templates */ TemplateIndex(103), + /* parameters */ ParameterIndex(344), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [260] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 4, + /* templates */ TemplateIndex(107), + /* parameters */ ParameterIndex(348), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [261] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(103), + /* parameters */ ParameterIndex(0), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [262] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(342), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [263] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(349), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [264] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(0), + /* templates */ TemplateIndex(103), + /* parameters */ ParameterIndex(8), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [265] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 6, + /* [263] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(93), - /* parameters */ ParameterIndex(8), + /* num_templates */ 1, + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(4), + /* return_matcher_indices */ MatcherIndicesIndex(8), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [264] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(9), + /* parameters */ ParameterIndex(752), + /* return_matcher_indices */ MatcherIndicesIndex(1119), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [265] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(72), + /* parameters */ ParameterIndex(1), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, @@ -12170,94 +12381,83 @@ constexpr OverloadInfo kOverloads[] = { /* [266] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(4), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(214), + /* parameters */ ParameterIndex(843), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [267] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(9), - /* parameters */ ParameterIndex(748), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(72), + /* parameters */ ParameterIndex(14), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [268] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 4, + /* templates */ TemplateIndex(154), + /* parameters */ ParameterIndex(844), + /* return_matcher_indices */ MatcherIndicesIndex(1137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [269] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, + /* num_parameters */ 3, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(184), - /* parameters */ ParameterIndex(839), - /* return_matcher_indices */ MatcherIndicesIndex(1103), + /* num_templates */ 4, + /* templates */ TemplateIndex(72), + /* parameters */ ParameterIndex(14), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [270] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 3, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 5, + /* templates */ TemplateIndex(72), + /* parameters */ ParameterIndex(758), + /* return_matcher_indices */ MatcherIndicesIndex(1146), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [271] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(132), - /* parameters */ ParameterIndex(840), - /* return_matcher_indices */ MatcherIndicesIndex(1109), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(4), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [272] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(761), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [273] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(754), - /* return_matcher_indices */ MatcherIndicesIndex(1118), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [274] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, /* templates */ TemplateIndex(10), @@ -12265,26 +12465,37 @@ constexpr OverloadInfo kOverloads[] = { /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, + { + /* [274] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(761), + /* return_matcher_indices */ MatcherIndicesIndex(994), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, { /* [275] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(757), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* num_templates */ 1, + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(4), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [276] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(4), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(764), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12293,31 +12504,31 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(757), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(13), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [278] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(4), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 3, + /* templates */ TemplateIndex(9), + /* parameters */ ParameterIndex(753), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [279] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(760), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* num_templates */ 3, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(846), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12325,10 +12536,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(10), - /* parameters */ ParameterIndex(345), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 4, + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(848), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12336,10 +12547,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(9), - /* parameters */ ParameterIndex(749), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 4, + /* templates */ TemplateIndex(162), + /* parameters */ ParameterIndex(850), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12347,131 +12558,131 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(208), - /* parameters */ ParameterIndex(842), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 5, + /* templates */ TemplateIndex(78), + /* parameters */ ParameterIndex(852), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [283] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(187), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* templates */ TemplateIndex(220), + /* parameters */ ParameterIndex(652), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [284] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(190), - /* parameters */ ParameterIndex(846), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 4, + /* templates */ TemplateIndex(130), + /* parameters */ ParameterIndex(656), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [285] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(136), - /* parameters */ ParameterIndex(848), - /* return_matcher_indices */ MatcherIndicesIndex(1103), + /* num_templates */ 3, + /* templates */ TemplateIndex(220), + /* parameters */ ParameterIndex(768), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [286] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(29), - /* parameters */ ParameterIndex(645), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 4, + /* templates */ TemplateIndex(130), + /* parameters */ ParameterIndex(771), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [287] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(185), - /* parameters */ ParameterIndex(649), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(166), + /* parameters */ ParameterIndex(14), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [288] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(29), - /* parameters */ ParameterIndex(764), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(166), + /* parameters */ ParameterIndex(844), + /* return_matcher_indices */ MatcherIndicesIndex(1137), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [289] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(185), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(13), + /* return_matcher_indices */ MatcherIndicesIndex(1016), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [290] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* templates */ TemplateIndex(167), + /* parameters */ ParameterIndex(842), + /* return_matcher_indices */ MatcherIndicesIndex(1161), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [291] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(840), - /* return_matcher_indices */ MatcherIndicesIndex(1109), + /* num_templates */ 2, + /* templates */ TemplateIndex(223), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [292] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(141), - /* parameters */ ParameterIndex(345), - /* return_matcher_indices */ MatcherIndicesIndex(1108), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(223), + /* parameters */ ParameterIndex(843), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [293] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(141), - /* parameters */ ParameterIndex(838), - /* return_matcher_indices */ MatcherIndicesIndex(1133), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(226), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12479,10 +12690,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(193), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 3, + /* templates */ TemplateIndex(226), + /* parameters */ ParameterIndex(843), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12490,10 +12701,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(193), - /* parameters */ ParameterIndex(839), - /* return_matcher_indices */ MatcherIndicesIndex(1103), + /* num_templates */ 2, + /* templates */ TemplateIndex(166), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12501,54 +12712,54 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(196), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 3, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(843), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [297] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(196), - /* parameters */ ParameterIndex(839), - /* return_matcher_indices */ MatcherIndicesIndex(1103), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [298] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(140), - /* parameters */ ParameterIndex(1), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(774), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, + { + /* [298] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(777), + /* return_matcher_indices */ MatcherIndicesIndex(1119), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, { /* [299] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(199), - /* parameters */ ParameterIndex(839), - /* return_matcher_indices */ MatcherIndicesIndex(1103), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(786), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [300] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(770), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(789), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12556,32 +12767,32 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(773), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(780), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [302] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(782), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(783), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [303] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(786), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12589,10 +12800,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(789), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12600,10 +12811,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(779), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(792), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12611,10 +12822,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(782), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(795), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12622,10 +12833,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(77), + /* parameters */ ParameterIndex(798), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12633,10 +12844,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(788), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(76), + /* parameters */ ParameterIndex(801), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12644,10 +12855,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(791), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(73), + /* parameters */ ParameterIndex(804), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12655,87 +12866,87 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(33), - /* parameters */ ParameterIndex(794), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* num_templates */ 2, + /* templates */ TemplateIndex(129), + /* parameters */ ParameterIndex(807), + /* return_matcher_indices */ MatcherIndicesIndex(1119), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [311] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(797), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(854), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [312] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(29), - /* parameters */ ParameterIndex(800), + /* templates */ TemplateIndex(10), + /* parameters */ ParameterIndex(856), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [313] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(803), - /* return_matcher_indices */ MatcherIndicesIndex(1091), + /* num_templates */ 1, + /* templates */ TemplateIndex(242), + /* parameters */ ParameterIndex(4), + /* return_matcher_indices */ MatcherIndicesIndex(1041), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [314] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(202), - /* parameters */ ParameterIndex(806), - /* return_matcher_indices */ MatcherIndicesIndex(624), + /* templates */ TemplateIndex(242), + /* parameters */ ParameterIndex(761), + /* return_matcher_indices */ MatcherIndicesIndex(1164), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [315] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(6), + /* parameters */ ParameterIndex(810), + /* return_matcher_indices */ MatcherIndicesIndex(629), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [316] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(93), + /* templates */ TemplateIndex(103), /* parameters */ ParameterIndex(8), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [316] */ + /* [317] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, /* templates */ TemplateIndex(9), - /* parameters */ ParameterIndex(748), - /* return_matcher_indices */ MatcherIndicesIndex(108), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [317] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 7, - /* templates */ TemplateIndex(0), - /* parameters */ ParameterIndex(869), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* parameters */ ParameterIndex(752), + /* return_matcher_indices */ MatcherIndicesIndex(32), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12745,19 +12956,19 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 1, /* num_templates */ 7, /* templates */ TemplateIndex(0), - /* parameters */ ParameterIndex(870), + /* parameters */ ParameterIndex(877), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [319] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(1043), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 7, + /* templates */ TemplateIndex(0), + /* parameters */ ParameterIndex(878), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12765,10 +12976,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(834), - /* return_matcher_indices */ MatcherIndicesIndex(1055), + /* num_templates */ 4, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(836), + /* return_matcher_indices */ MatcherIndicesIndex(1067), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12777,9 +12988,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(836), - /* return_matcher_indices */ MatcherIndicesIndex(1103), + /* templates */ TemplateIndex(211), + /* parameters */ ParameterIndex(838), + /* return_matcher_indices */ MatcherIndicesIndex(1079), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12788,9 +12999,9 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(762), - /* return_matcher_indices */ MatcherIndicesIndex(1103), + /* templates */ TemplateIndex(211), + /* parameters */ ParameterIndex(840), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12798,21 +13009,21 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(758), - /* return_matcher_indices */ MatcherIndicesIndex(976), + /* num_templates */ 3, + /* templates */ TemplateIndex(211), + /* parameters */ ParameterIndex(766), + /* return_matcher_indices */ MatcherIndicesIndex(1131), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [324] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(210), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(8), + /* templates */ TemplateIndex(158), + /* parameters */ ParameterIndex(762), + /* return_matcher_indices */ MatcherIndicesIndex(994), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12821,7 +13032,7 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(212), + /* templates */ TemplateIndex(239), /* parameters */ ParameterIndex(1), /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), @@ -12829,23 +13040,23 @@ constexpr OverloadInfo kOverloads[] = { { /* [326] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(837), - /* return_matcher_indices */ MatcherIndicesIndex(1051), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(8), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [327] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(329), - /* return_matcher_indices */ MatcherIndicesIndex(606), + /* num_templates */ 3, + /* templates */ TemplateIndex(211), + /* parameters */ ParameterIndex(841), + /* return_matcher_indices */ MatcherIndicesIndex(1075), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -12855,8 +13066,19 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(329), - /* return_matcher_indices */ MatcherIndicesIndex(624), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(611), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [329] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(629), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, }; @@ -12867,169 +13089,169 @@ static_assert(OverloadIndex::CanIndex(kOverloads), constexpr IntrinsicInfo kBuiltins[] = { { /* [0] */ - /* fn array_length[I : u32, A : access](ptr, I) -> u32 */ + /* fn array_length[A : access](ptr, literal) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(314), + /* overloads */ OverloadIndex(315), }, { /* [1] */ /* fn atomic_load[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U) -> T */ - /* fn atomic_load[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U) -> T */ + /* fn atomic_load[T : iu32, U : u32, S : workgroup_or_storage, AM : readable](ptr, U, U) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(260), + /* overloads */ OverloadIndex(257), }, { /* [2] */ /* fn atomic_store[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) */ - /* fn atomic_store[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) */ + /* fn atomic_store[T : iu32, U : u32, S : workgroup_or_storage, AM : writable](ptr, U, U, T) */ /* num overloads */ 2, - /* overloads */ OverloadIndex(262), + /* overloads */ OverloadIndex(259), }, { /* [3] */ /* fn atomic_exchange[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_exchange[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_exchange[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [4] */ /* fn atomic_compare_exchange[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, U, T, T) -> T */ - /* fn atomic_compare_exchange[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, U, T, T) -> T */ + /* fn atomic_compare_exchange[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, U, T, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(264), + /* overloads */ OverloadIndex(261), }, { /* [5] */ /* fn atomic_i_add[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_i_add[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_i_add[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [6] */ /* fn atomic_i_sub[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_i_sub[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_i_sub[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [7] */ /* fn atomic_s_max[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_s_max[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_s_max[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [8] */ /* fn atomic_s_min[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_s_min[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_s_min[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [9] */ /* fn atomic_u_max[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_u_max[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_u_max[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* fn atomic_u_max(ptr, read_write>, u32, u32, u64) -> u64 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [10] */ /* fn atomic_u_min[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_u_min[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_u_min[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* fn atomic_u_min(ptr, read_write>, u32, u32, u64) -> u64 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [11] */ /* fn atomic_and[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_and[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_and[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [12] */ /* fn atomic_or[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_or[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_or[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [13] */ /* fn atomic_xor[T : iu32, U : u32, S : workgroup_or_storage](ptr, read_write>, U, U, T) -> T */ - /* fn atomic_xor[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ + /* fn atomic_xor[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U, T) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(242), + /* overloads */ OverloadIndex(239), }, { /* [14] */ - /* fn atomic_i_increment[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U) -> T */ + /* fn atomic_i_increment[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(315), + /* overloads */ OverloadIndex(316), }, { /* [15] */ - /* fn atomic_i_decrement[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U) -> T */ + /* fn atomic_i_decrement[T : iu32, U : u32, S : workgroup_or_storage](ptr, U, U) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(315), + /* overloads */ OverloadIndex(316), }, { /* [16] */ /* fn dot[N : num, T : f32_f16](vec, vec) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(316), + /* overloads */ OverloadIndex(317), }, { /* [17] */ - /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec2, dref: f32, image_operands: u32) -> vec4 */ - /* fn image_dref_gather[F : texel_format, A : access, Z : iu32](image: sampled_image>, coords: vec2, dref: f32, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32) -> vec4 */ - /* fn image_dref_gather[F : texel_format, A : access, Z : iu32](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32) -> vec4 */ - /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32) -> vec4 */ + /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec2, dref: f32, image_operands: literal) -> vec4 */ + /* fn image_dref_gather[F : texel_format, A : access, Z : iu32](image: sampled_image>, coords: vec2, dref: f32, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal) -> vec4 */ + /* fn image_dref_gather[F : texel_format, A : access, Z : iu32](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal) -> vec4 */ + /* fn image_dref_gather[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal) -> vec4 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(218), + /* overloads */ OverloadIndex(209), }, { /* [18] */ - /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_fetch[C : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_fetch[C : iu32, F : texel_format](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_fetch[C : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: C, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec3, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec3, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[C : iu32, Z : iu32, F : texel_format](image: image, coords: vec3, image_operands: u32, sample: Z) -> vec4 */ - /* fn image_fetch[C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: u32, sample: Z) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_fetch[C : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_fetch[C : iu32, F : texel_format](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_fetch[C : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: C, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec3, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec3, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[C : iu32, Z : iu32, F : texel_format](image: image, coords: vec3, image_operands: literal, sample: Z) -> vec4 */ + /* fn image_fetch[C : iu32, Z : iu32, F : texel_format](image: image, coords: vec2, image_operands: literal, sample: Z) -> vec4 */ /* num overloads */ 16, - /* overloads */ OverloadIndex(107), + /* overloads */ OverloadIndex(124), }, { /* [19] */ - /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec4, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: u32) -> vec4 */ - /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec4, component: C, image_operands: u32) -> vec4 */ + /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[T : fiu32, C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[T : fiu32, C : iu32, F : texel_format](image: sampled_image>, coords: vec4, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec2, component: C, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[C : iu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec3, component: C, image_operands: literal) -> vec4 */ + /* fn image_gather[C : iu32, F : texel_format](image: sampled_image>, coords: vec4, component: C, image_operands: literal) -> vec4 */ /* num overloads */ 12, - /* overloads */ OverloadIndex(167), + /* overloads */ OverloadIndex(168), }, { /* [20] */ @@ -13047,7 +13269,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn image_query_size[F : texel_format, A : access](image: image) -> vec3 */ /* fn image_query_size[S : sampled, F : texel_format, A : access](image: image) -> vec2 */ /* num overloads */ 13, - /* overloads */ OverloadIndex(154), + /* overloads */ OverloadIndex(155), }, { /* [21] */ @@ -13063,233 +13285,234 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn image_query_size_lod[L : iu32, S : sampled, F : texel_format, A : access](image: image, level: L) -> vec2 */ /* fn image_query_size_lod[L : iu32, S : sampled, F : texel_format, A : access](image: image, level: L) -> vec3 */ /* num overloads */ 11, - /* overloads */ OverloadIndex(179), + /* overloads */ OverloadIndex(180), }, { /* [22] */ /* fn image_query_levels[T : fiu32, D : depth, R : arrayed, S : sampled, F : texel_format, A : access](image: image) -> Z */ /* num overloads */ 1, - /* overloads */ OverloadIndex(317), + /* overloads */ OverloadIndex(318), }, { /* [23] */ /* fn image_query_samples[T : fiu32, D : depth, R : arrayed, S : sampled, F : texel_format, A : access](image: image) -> Z */ /* num overloads */ 1, - /* overloads */ OverloadIndex(318), + /* overloads */ OverloadIndex(319), }, { /* [24] */ - /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: u32) -> vec4 */ - /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: vec2, image_operands: u32) -> vec4 */ - /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: u32) -> vec4 */ + /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: C, image_operands: literal) -> vec4 */ + /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: vec2, image_operands: literal) -> vec4 */ + /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_read[F : f32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_read[F : i32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_read[F : u32_texel_format, A : readable, C : iu32](image: image, coords: vec3, image_operands: literal) -> vec4 */ /* fn image_read[F : texel_format, T : fiu32, C : iu32, A : readable](image: image, coords: vec2) -> vec4 */ - /* num overloads */ 16, - /* overloads */ OverloadIndex(123), + /* fn image_read[F : texel_format, T : fiu32, Z : iu32, C : iu32, A : readable](image: image, coords: vec2, image_operands: literal, sample: Z) -> vec4 */ + /* num overloads */ 17, + /* overloads */ OverloadIndex(73), }, { /* [25] */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: f32, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, bias: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32, const_offset: vec3) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32, const_offset: vec3) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, const_offset: vec3) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, const_offset: vec3) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_implicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: f32, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, bias: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32, const_offset: vec3) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32, const_offset: vec3) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, const_offset: vec3) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, const_offset: vec3) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_implicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ /* num overloads */ 37, /* overloads */ OverloadIndex(0), }, { /* [26] */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, bias: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, bias: f32, const_offset: vec3) -> vec4 */ - /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, const_offset: vec3) -> vec4 */ - /* fn image_sample_proj_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32) -> vec4 */ - /* fn image_sample_proj_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, bias: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, bias: f32, const_offset: vec3) -> vec4 */ + /* fn image_sample_proj_implicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, const_offset: vec3) -> vec4 */ + /* fn image_sample_proj_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal) -> vec4 */ + /* fn image_sample_proj_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal) -> vec4 */ + /* fn image_sample_proj_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, const_offset: vec2) -> vec4 */ /* num overloads */ 17, - /* overloads */ OverloadIndex(73), + /* overloads */ OverloadIndex(90), }, { /* [27] */ - /* fn image_sample_proj_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_proj_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_proj_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, const_offset: vec2) -> f32 */ - /* fn image_sample_proj_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, const_offset: vec2) -> f32 */ + /* fn image_sample_proj_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_proj_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_proj_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, const_offset: vec2) -> f32 */ + /* fn image_sample_proj_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, const_offset: vec2) -> f32 */ /* num overloads */ 4, - /* overloads */ OverloadIndex(230), + /* overloads */ OverloadIndex(227), }, { /* [28] */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: f32, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32, const_offset: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32, const_offset: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec3, ddy: vec3, const_offset: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec3, ddy: vec3, const_offset: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn image_sample_explicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: f32, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, ddx: vec2, ddy: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec2, ddy: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec2, ddy: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec3, ddy: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec3, ddy: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32, const_offset: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32, const_offset: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec3, ddy: vec3, const_offset: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec3, ddy: vec3, const_offset: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec3, ddy: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec3, ddy: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec3, ddy: vec3) -> vec4 */ + /* fn image_sample_explicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ /* num overloads */ 36, /* overloads */ OverloadIndex(37), }, { /* [29] */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32, const_offset: vec3) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, ddx: vec3, ddy: vec3, const_offset: vec3) -> vec4 */ - /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_proj_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_proj_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32) -> vec4 */ - /* fn image_sample_proj_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ - /* fn image_sample_proj_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: u32, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec2, ddy: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec2, ddy: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec2, ddy: vec2, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec3, ddy: vec3) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32, const_offset: vec3) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, ddx: vec3, ddy: vec3, const_offset: vec3) -> vec4 */ + /* fn image_sample_proj_explicit_lod[T : fiu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_proj_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_proj_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32) -> vec4 */ + /* fn image_sample_proj_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ + /* fn image_sample_proj_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, image_operands: literal, lod: f32, const_offset: vec2) -> vec4 */ /* num overloads */ 17, - /* overloads */ OverloadIndex(90), + /* overloads */ OverloadIndex(107), }, { /* [30] */ - /* fn image_sample_proj_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_proj_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_proj_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, lod: f32, const_offset: vec2) -> f32 */ - /* fn image_sample_proj_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, lod: f32, const_offset: vec2) -> f32 */ + /* fn image_sample_proj_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_proj_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_proj_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, lod: f32, const_offset: vec2) -> f32 */ + /* fn image_sample_proj_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, lod: f32, const_offset: vec2) -> f32 */ /* num overloads */ 4, - /* overloads */ OverloadIndex(234), + /* overloads */ OverloadIndex(231), }, { /* [31] */ - /* fn image_sample_dref_implicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_dref_implicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: u32, const_offset: vec2) -> f32 */ - /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, const_offset: vec2) -> f32 */ - /* fn image_sample_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, const_offset: vec2) -> f32 */ - /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32) -> f32 */ - /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32) -> f32 */ + /* fn image_sample_dref_implicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_dref_implicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: literal, const_offset: vec2) -> f32 */ + /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, const_offset: vec2) -> f32 */ + /* fn image_sample_dref_implicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, const_offset: vec2) -> f32 */ + /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal) -> f32 */ + /* fn image_sample_dref_implicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal) -> f32 */ + /* num overloads */ 9, + /* overloads */ OverloadIndex(191), + }, + { + /* [32] */ + /* fn image_sample_dref_explicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_dref_explicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: literal, lod: f32, const_offset: vec2) -> f32 */ + /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, lod: f32, const_offset: vec2) -> f32 */ + /* fn image_sample_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, lod: f32, const_offset: vec2) -> f32 */ + /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, lod: f32) -> f32 */ + /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: literal, lod: f32) -> f32 */ /* num overloads */ 9, /* overloads */ OverloadIndex(200), }, - { - /* [32] */ - /* fn image_sample_dref_explicit_lod[F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_dref_explicit_lod[Z : iu32, F : texel_format, N : num](image: sampled_image>, coords: vec, dref: f32, image_operands: u32, lod: f32, const_offset: vec2) -> f32 */ - /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, lod: f32, const_offset: vec2) -> f32 */ - /* fn image_sample_dref_explicit_lod[Z : iu32, F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, lod: f32, const_offset: vec2) -> f32 */ - /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec3, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* fn image_sample_dref_explicit_lod[F : texel_format](image: sampled_image>, coords: vec4, dref: f32, image_operands: u32, lod: f32) -> f32 */ - /* num overloads */ 9, - /* overloads */ OverloadIndex(209), - }, { /* [33] */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec2, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec2, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec2, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: u32) */ - /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: u32) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: C, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec2, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec2, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec2, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: literal) */ + /* fn image_write[C : iu32, F : texel_format, A : access](image: image, coords: vec3, texel: vec4, image_operands: literal) */ /* num overloads */ 15, - /* overloads */ OverloadIndex(139), + /* overloads */ OverloadIndex(140), }, { /* [34] */ @@ -13300,40 +13523,36 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn op_image>[F : texel_format](sampled_image) -> I */ /* fn op_image>[F : texel_format](sampled_image) -> I */ /* num overloads */ 6, - /* overloads */ OverloadIndex(224), + /* overloads */ OverloadIndex(215), }, { /* [35] */ /* fn op_sampled_image>[T : fiu32, S : samplers, F : texel_format](I, S) -> sampled_image */ - /* fn op_sampled_image>[T : f32, K : sampler_filter, F : texel_format](I, sampler_filtered) -> sampled_image */ /* fn op_sampled_image>[T : fiu32, S : samplers, F : texel_format](I, S) -> sampled_image */ - /* fn op_sampled_image>[T : f32, K : sampler_filter, F : texel_format](I, sampler_filtered) -> sampled_image */ /* fn op_sampled_image>[T : fiu32, S : samplers, F : texel_format](I, S) -> sampled_image */ - /* fn op_sampled_image>[T : f32, K : sampler_filter, F : texel_format](I, sampler_filtered) -> sampled_image */ /* fn op_sampled_image>[T : fiu32, S : samplers, F : texel_format](I, S) -> sampled_image */ - /* fn op_sampled_image>[T : f32, K : sampler_filter, F : texel_format](I, sampler_filtered) -> sampled_image */ /* fn op_sampled_image>[S : samplers, F : texel_format](I, S) -> sampled_image */ /* fn op_sampled_image>[S : samplers, F : texel_format](I, S) -> sampled_image */ - /* num overloads */ 10, - /* overloads */ OverloadIndex(190), + /* num overloads */ 6, + /* overloads */ OverloadIndex(221), }, { /* [36] */ /* fn matrix_times_matrix[T : f32_f16, K : num, C : num, R : num](mat, mat) -> mat */ /* num overloads */ 1, - /* overloads */ OverloadIndex(319), + /* overloads */ OverloadIndex(320), }, { /* [37] */ /* fn matrix_times_scalar[T : f32_f16, N : num, M : num](mat, T) -> mat */ /* num overloads */ 1, - /* overloads */ OverloadIndex(320), + /* overloads */ OverloadIndex(321), }, { /* [38] */ /* fn matrix_times_vector[T : f32_f16, N : num, M : num](mat, vec) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(321), + /* overloads */ OverloadIndex(322), }, { /* [39] */ @@ -13341,26 +13560,26 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn select[N : num, T : scalar](bool, vec, vec) -> vec */ /* fn select[N : num, T : scalar](vec, vec, vec) -> vec */ /* num overloads */ 3, - /* overloads */ OverloadIndex(245), + /* overloads */ OverloadIndex(242), }, { /* [40] */ /* fn vector_times_matrix[T : f32_f16, N : num, M : num](vec, mat) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(322), + /* overloads */ OverloadIndex(323), }, { /* [41] */ /* fn vector_times_scalar[T : f32_f16, N : num](vec, T) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(323), + /* overloads */ OverloadIndex(324), }, { /* [42] */ /* fn normalize[T : f32_f16](T) -> T */ /* fn normalize[N : num, T : f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(266), + /* overloads */ OverloadIndex(263), }, { /* [43] */ @@ -13368,468 +13587,482 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn inverse[T : f32_f16](mat3x3) -> mat3x3 */ /* fn inverse[T : f32_f16](mat4x4) -> mat4x4 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(248), + /* overloads */ OverloadIndex(245), }, { /* [44] */ /* fn sign[T : iu32](T) -> R */ /* fn sign[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(268), + /* overloads */ OverloadIndex(265), }, { /* [45] */ /* fn abs[T : iu32](T) -> R */ /* fn abs[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(268), + /* overloads */ OverloadIndex(265), }, { /* [46] */ /* fn s_max[T : iu32, U : iu32](T, U) -> R */ /* fn s_max[T : iu32, U : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(270), + /* overloads */ OverloadIndex(267), }, { /* [47] */ /* fn s_min[T : iu32, U : iu32](T, U) -> R */ /* fn s_min[T : iu32, U : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(270), + /* overloads */ OverloadIndex(267), }, { /* [48] */ /* fn s_clamp[T : iu32, U : iu32, V : iu32](T, U, V) -> R */ /* fn s_clamp[T : iu32, U : iu32, V : iu32, N : num](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(272), + /* overloads */ OverloadIndex(269), }, { /* [49] */ /* fn u_max[T : iu32, U : iu32](T, U) -> R */ /* fn u_max[T : iu32, U : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(270), + /* overloads */ OverloadIndex(267), }, { /* [50] */ /* fn u_min[T : iu32, U : iu32](T, U) -> R */ /* fn u_min[T : iu32, U : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(270), + /* overloads */ OverloadIndex(267), }, { /* [51] */ /* fn u_clamp[T : iu32, U : iu32, V : iu32](T, U, V) -> R */ /* fn u_clamp[T : iu32, U : iu32, V : iu32, N : num](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(272), + /* overloads */ OverloadIndex(269), }, { /* [52] */ /* fn find_i_lsb[T : iu32](T) -> R */ /* fn find_i_lsb[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(268), + /* overloads */ OverloadIndex(265), }, { /* [53] */ /* fn find_s_msb[T : iu32](T) -> R */ /* fn find_s_msb[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(268), + /* overloads */ OverloadIndex(265), }, { /* [54] */ /* fn find_u_msb[T : iu32](T) -> R */ /* fn find_u_msb[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(268), + /* overloads */ OverloadIndex(265), }, { /* [55] */ /* fn refract[T : f32_f16](T, T, T) -> T */ /* fn refract[T : f32_f16, N : num](vec, vec, T) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(274), + /* overloads */ OverloadIndex(271), }, { /* [56] */ /* fn reflect[T : f32_f16](T, T) -> T */ /* fn reflect[T : f32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(276), + /* overloads */ OverloadIndex(273), }, { /* [57] */ /* fn face_forward[T : f32_f16](T, T, T) -> T */ /* fn face_forward[T : f32_f16, N : num](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(278), + /* overloads */ OverloadIndex(275), }, { /* [58] */ /* fn ldexp[T : f32_f16, U : iu32](T, U) -> T */ /* fn ldexp[N : num, T : f32_f16, U : iu32](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(280), + /* overloads */ OverloadIndex(277), }, { /* [59] */ - /* fn modf[T : f32_f16, S : function_private_workgroup_storage](x: T, i: ptr) -> T */ - /* fn modf[T : f32_f16, N : num, S : function_private_workgroup_storage](x: vec, i: ptr, writable>) -> vec */ + /* fn modf[T : f32_f16, S : function_private_workgroup_storage, AM : writable](x: T, i: ptr) -> T */ + /* fn modf[T : f32_f16, N : num, S : function_private_workgroup_storage, AM : writable](x: vec, i: ptr, AM>) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(282), + /* overloads */ OverloadIndex(279), }, { /* [60] */ - /* fn frexp[T : f32_f16, R : iu32, S : function_private_workgroup_storage](x: T, i: ptr) -> T */ - /* fn frexp[T : f32_f16, R : iu32, N : num, S : function_private_workgroup_storage](x: vec, i: ptr, writable>) -> vec */ + /* fn frexp[T : f32_f16, R : iu32, S : function_private_workgroup_storage, AM : writable](x: T, i: ptr) -> T */ + /* fn frexp[T : f32_f16, R : iu32, N : num, S : function_private_workgroup_storage, AM : writable](x: vec, i: ptr, AM>) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(284), + /* overloads */ OverloadIndex(281), }, { /* [61] */ /* fn bit_count[T : iu32](T) -> R */ /* fn bit_count[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(268), + /* overloads */ OverloadIndex(265), }, { /* [62] */ - /* fn bit_field_insert[T : iu32](base: T, insert: T, offset: iu32, count: iu32) -> T */ - /* fn bit_field_insert[T : iu32, N : num](base: vec, insert: vec, offset: iu32, count: iu32) -> vec */ + /* fn bit_field_insert[T : iu32, OT : iu32, CT : iu32](base: T, insert: T, offset: OT, count: CT) -> T */ + /* fn bit_field_insert[T : iu32, N : num, OT : iu32, CT : iu32](base: vec, insert: vec, offset: OT, count: CT) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(286), + /* overloads */ OverloadIndex(283), }, { /* [63] */ - /* fn bit_field_s_extract[T : iu32](base: T, offset: iu32, count: iu32) -> T */ - /* fn bit_field_s_extract[T : iu32, N : num](base: vec, offset: iu32, count: iu32) -> vec */ + /* fn bit_field_s_extract[T : iu32, OT : iu32, CT : iu32](base: T, offset: OT, count: CT) -> T */ + /* fn bit_field_s_extract[T : iu32, N : num, OT : iu32, CT : iu32](base: vec, offset: OT, count: CT) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(288), + /* overloads */ OverloadIndex(285), }, { /* [64] */ - /* fn bit_field_u_extract[T : iu32](base: T, offset: iu32, count: iu32) -> T */ - /* fn bit_field_u_extract[T : iu32, N : num](base: vec, offset: iu32, count: iu32) -> vec */ + /* fn bit_field_u_extract[T : iu32, OT : iu32, CT : iu32](base: T, offset: OT, count: CT) -> T */ + /* fn bit_field_u_extract[T : iu32, N : num, OT : iu32, CT : iu32](base: vec, offset: OT, count: CT) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(288), + /* overloads */ OverloadIndex(285), }, { /* [65] */ /* fn add[A : iu32, B : iu32](A, B) -> R */ /* fn add[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [66] */ /* fn sub[A : iu32, B : iu32](A, B) -> R */ /* fn sub[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [67] */ /* fn mul[A : iu32, B : iu32](A, B) -> R */ /* fn mul[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [68] */ /* fn s_div[A : iu32, B : iu32](A, B) -> R */ /* fn s_div[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [69] */ /* fn s_mod[A : iu32, B : iu32](A, B) -> R */ /* fn s_mod[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [70] */ /* fn s_greater_than[A : iu32, B : iu32](A, B) -> bool */ /* fn s_greater_than[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [71] */ /* fn s_greater_than_equal[A : iu32, B : iu32](A, B) -> bool */ /* fn s_greater_than_equal[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [72] */ /* fn s_less_than[A : iu32, B : iu32](A, B) -> bool */ /* fn s_less_than[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [73] */ /* fn s_less_than_equal[A : iu32, B : iu32](A, B) -> bool */ /* fn s_less_than_equal[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [74] */ /* fn u_greater_than[A : iu32, B : iu32](A, B) -> bool */ /* fn u_greater_than[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [75] */ /* fn u_greater_than_equal[A : iu32, B : iu32](A, B) -> bool */ /* fn u_greater_than_equal[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [76] */ /* fn u_less_than[A : iu32, B : iu32](A, B) -> bool */ /* fn u_less_than[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [77] */ /* fn u_less_than_equal[A : iu32, B : iu32](A, B) -> bool */ /* fn u_less_than_equal[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [78] */ /* fn convert_f_to_s[T : f32_f16](T) -> R */ /* fn convert_f_to_s[T : f32_f16, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(294), + /* overloads */ OverloadIndex(291), }, { /* [79] */ /* fn convert_s_to_f[T : iu32](T) -> R */ /* fn convert_s_to_f[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(296), + /* overloads */ OverloadIndex(293), }, { /* [80] */ /* fn convert_u_to_f[T : iu32](T) -> R */ /* fn convert_u_to_f[T : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(296), + /* overloads */ OverloadIndex(293), }, { /* [81] */ /* fn s_convert[T : i32](T) -> K */ /* num overloads */ 1, - /* overloads */ OverloadIndex(324), + /* overloads */ OverloadIndex(325), }, { /* [82] */ /* fn u_convert[T : u32](T) -> K */ /* num overloads */ 1, - /* overloads */ OverloadIndex(325), + /* overloads */ OverloadIndex(326), }, { /* [83] */ /* fn bitwise_and[A : iu32, B : iu32](A, B) -> R */ /* fn bitwise_and[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [84] */ /* fn bitwise_or[A : iu32, B : iu32](A, B) -> R */ /* fn bitwise_or[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [85] */ /* fn bitwise_xor[A : iu32, B : iu32](A, B) -> R */ /* fn bitwise_xor[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [86] */ /* fn equal[A : iu32, B : iu32](A, B) -> bool */ /* fn equal[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [87] */ /* fn not_equal[A : iu32, B : iu32](A, B) -> bool */ /* fn not_equal[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(292), + /* overloads */ OverloadIndex(289), }, { /* [88] */ /* fn shift_left_logical[A : iu32, B : iu32](A, B) -> R */ /* fn shift_left_logical[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [89] */ /* fn shift_right_logical[A : iu32, B : iu32](A, B) -> R */ /* fn shift_right_logical[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [90] */ /* fn shift_right_arithmetic[A : iu32, B : iu32](A, B) -> R */ /* fn shift_right_arithmetic[A : iu32, B : iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(290), + /* overloads */ OverloadIndex(287), }, { /* [91] */ /* fn not[A : iu32](A) -> R */ /* fn not[A : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(298), + /* overloads */ OverloadIndex(295), }, { /* [92] */ /* fn s_negate[A : iu32](A) -> R */ /* fn s_negate[A : iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(298), + /* overloads */ OverloadIndex(295), }, { /* [93] */ /* fn f_mod[T : f32_f16](T, T) -> T */ /* fn f_mod[T : f32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(276), + /* overloads */ OverloadIndex(273), }, { /* [94] */ /* fn outer_product[T : f32_f16, N : num, M : num](vec, vec) -> mat */ /* num overloads */ 1, - /* overloads */ OverloadIndex(326), - }, - { - /* [95] */ - /* fn s_dot(u32, u32, u32) -> i32 */ - /* num overloads */ 1, /* overloads */ OverloadIndex(327), }, { - /* [96] */ - /* fn u_dot(u32, u32, u32) -> u32 */ + /* [95] */ + /* fn s_dot(u32, u32, literal) -> i32 */ /* num overloads */ 1, /* overloads */ OverloadIndex(328), }, + { + /* [96] */ + /* fn u_dot(u32, u32, literal) -> u32 */ + /* num overloads */ 1, + /* overloads */ OverloadIndex(329), + }, { /* [97] */ - /* fn cooperative_matrix_load>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num](ptr, u32, u32, u32) -> T */ - /* fn cooperative_matrix_load>[K : subgroup_matrix_kind, S : i8, C : num, R : num](ptr, u32, u32, u32) -> T */ - /* fn cooperative_matrix_load>[K : subgroup_matrix_kind, S : u8, C : num, R : num](ptr, u32, u32, u32) -> T */ + /* fn cooperative_matrix_load>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AS : workgroup_or_storage, AM : readable](ptr, u32, u32, literal) -> T */ + /* fn cooperative_matrix_load>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AS : workgroup_or_storage, AM : readable](ptr, u32, u32, literal) -> T */ + /* fn cooperative_matrix_load>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AS : workgroup_or_storage, AM : readable](ptr, u32, u32, literal) -> T */ + /* num overloads */ 3, + /* overloads */ OverloadIndex(248), + }, + { + /* [98] */ + /* fn cooperative_matrix_store[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AS : workgroup_or_storage, AM : writable](ptr, subgroup_matrix, u32, u32, literal) */ + /* fn cooperative_matrix_store[K : subgroup_matrix_kind, S : i8, C : num, R : num, AS : workgroup_or_storage, AM : writable](ptr, subgroup_matrix, u32, u32, literal) */ + /* fn cooperative_matrix_store[K : subgroup_matrix_kind, S : u8, C : num, R : num, AS : workgroup_or_storage, AM : writable](ptr, subgroup_matrix, u32, u32, literal) */ /* num overloads */ 3, /* overloads */ OverloadIndex(251), }, - { - /* [98] */ - /* fn cooperative_matrix_store[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num](ptr, subgroup_matrix, u32, u32, u32) */ - /* fn cooperative_matrix_store[K : subgroup_matrix_kind, S : i8, C : num, R : num](ptr, subgroup_matrix, u32, u32, u32) */ - /* fn cooperative_matrix_store[K : subgroup_matrix_kind, S : u8, C : num, R : num](ptr, subgroup_matrix, u32, u32, u32) */ - /* num overloads */ 3, - /* overloads */ OverloadIndex(254), - }, { /* [99] */ - /* fn cooperative_matrix_mul_add[T : f16, TR : f32_f16, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, u32) -> subgroup_matrix */ - /* fn cooperative_matrix_mul_add[T : f32, TR : f32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, u32) -> subgroup_matrix */ - /* fn cooperative_matrix_mul_add[T : iu32, TR : iu32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, u32) -> subgroup_matrix */ - /* fn cooperative_matrix_mul_add[T : iu8, TR : iu32_iu8, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, u32) -> subgroup_matrix */ + /* fn cooperative_matrix_mul_add[T : f16, TR : f32_f16, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, literal) -> subgroup_matrix */ + /* fn cooperative_matrix_mul_add[T : f32, TR : f32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, literal) -> subgroup_matrix */ + /* fn cooperative_matrix_mul_add[T : iu32, TR : iu32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, literal) -> subgroup_matrix */ + /* fn cooperative_matrix_mul_add[T : iu8, TR : iu32_iu8, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix, literal) -> subgroup_matrix */ /* num overloads */ 4, - /* overloads */ OverloadIndex(238), + /* overloads */ OverloadIndex(235), }, { /* [100] */ /* fn group_non_uniform_broadcast[T : scalar](scope: u32, e: T, @const id: u32) -> T */ /* fn group_non_uniform_broadcast[N : num, T : scalar](scope: u32, e: vec, @const id: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(300), + /* overloads */ OverloadIndex(297), }, { /* [101] */ /* fn group_non_uniform_broadcast_first[T : scalar](scope: u32, value: T) -> T */ /* fn group_non_uniform_broadcast_first[N : num, T : scalar](scope: u32, value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(302), + /* overloads */ OverloadIndex(299), }, { /* [102] */ /* fn group_non_uniform_quad_broadcast[T : scalar](scope: u32, e: T, @const id: u32) -> T */ /* fn group_non_uniform_quad_broadcast[N : num, T : scalar](scope: u32, e: vec, @const id: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(300), + /* overloads */ OverloadIndex(297), }, { /* [103] */ /* fn group_non_uniform_quad_swap[T : scalar](scope: u32, e: T, @const dir: u32) -> T */ /* fn group_non_uniform_quad_swap[N : num, T : scalar](scope: u32, e: vec, @const dir: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(304), + /* overloads */ OverloadIndex(301), }, { /* [104] */ /* fn group_non_uniform_shuffle[T : scalar](scope: u32, value: T, id: u32) -> T */ /* fn group_non_uniform_shuffle[N : num, T : scalar](scope: u32, value: vec, id: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(306), + /* overloads */ OverloadIndex(303), }, { /* [105] */ /* fn group_non_uniform_shuffle_xor[T : scalar](scope: u32, value: T, mask: u32) -> T */ /* fn group_non_uniform_shuffle_xor[N : num, T : scalar](scope: u32, value: vec, mask: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(308), + /* overloads */ OverloadIndex(305), }, { /* [106] */ /* fn group_non_uniform_shuffle_down[T : scalar](scope: u32, value: T, delta: u32) -> T */ /* fn group_non_uniform_shuffle_down[N : num, T : scalar](scope: u32, value: vec, delta: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(310), + /* overloads */ OverloadIndex(307), }, { /* [107] */ /* fn group_non_uniform_shuffle_up[T : scalar](scope: u32, value: T, delta: u32) -> T */ /* fn group_non_uniform_shuffle_up[N : num, T : scalar](scope: u32, value: vec, delta: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(310), + /* overloads */ OverloadIndex(307), }, { /* [108] */ /* fn group_non_uniform_s_min[T : iu32](scope: u32, group_operation: u32, value: T) -> T */ /* fn group_non_uniform_s_min[N : num, T : iu32](scope: u32, group_operation: u32, value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(312), + /* overloads */ OverloadIndex(309), }, { /* [109] */ /* fn group_non_uniform_s_max[T : iu32](scope: u32, group_operation: u32, value: T) -> T */ /* fn group_non_uniform_s_max[N : num, T : iu32](scope: u32, group_operation: u32, value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(312), + /* overloads */ OverloadIndex(309), + }, + { + /* [110] */ + /* fn interpolate_at_offset[T : f32_f16, N : num](ptr, readable>, vec2) -> vec */ + /* fn interpolate_at_offset[T : f32_f16](ptr, vec2) -> T */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(311), + }, + { + /* [111] */ + /* fn add_carry[T : u32](T, T) -> struct_add_carry_scalar */ + /* fn add_carry[T : u32, N : num](vec, vec) -> struct_add_carry_vec */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(313), }, }; @@ -13840,7 +14073,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op +[K : subgroup_matrix_kind, C : num, R : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* op +[K : subgroup_matrix_kind, C : num, R : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(257), + /* overloads */ OverloadIndex(254), }, { /* [1] */ @@ -13848,7 +14081,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op -[K : subgroup_matrix_kind, C : num, R : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* op -[K : subgroup_matrix_kind, C : num, R : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(257), + /* overloads */ OverloadIndex(254), }, { /* [2] */ @@ -13856,7 +14089,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op *[K : subgroup_matrix_kind, C : num, R : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* op *[K : subgroup_matrix_kind, C : num, R : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(257), + /* overloads */ OverloadIndex(254), }, }; constexpr uint8_t kBinaryOperatorPlus = 0; @@ -13872,8 +14105,8 @@ const core::intrinsic::TableData Dialect::kData{ /* number_matchers */ kNumberMatchers, /* parameters */ kParameters, /* overloads */ kOverloads, - /* const_eval_functions */ Empty, - /* ctor_conv */ Empty, + /* const_eval_functions */ {}, + /* ctor_conv */ {}, /* builtins */ kBuiltins, /* binary '+' */ kBinaryOperators[kBinaryOperatorPlus], /* binary '-' */ kBinaryOperators[kBinaryOperatorMinus], diff --git a/3rdparty/dawn/src/tint/lang/spirv/intrinsic/type_matchers.h b/3rdparty/dawn/src/tint/lang/spirv/intrinsic/type_matchers.h index 1a6380ab1..ee029a5f3 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/intrinsic/type_matchers.h +++ b/3rdparty/dawn/src/tint/lang/spirv/intrinsic/type_matchers.h @@ -30,12 +30,27 @@ #include "src/tint/lang/core/intrinsic/table.h" #include "src/tint/lang/core/type/array.h" +#include "src/tint/lang/core/type/builtin_structs.h" #include "src/tint/lang/core/type/manager.h" #include "src/tint/lang/core/type/struct.h" +#include "src/tint/lang/core/type/vector.h" +#include "src/tint/lang/spirv/type/literal.h" #include "src/tint/lang/spirv/type/sampled_image.h" namespace tint::spirv::intrinsic { +inline bool MatchLiteral(core::intrinsic::MatchState&, const core::type::Type* ty) { + if (ty->Is()) { + return true; + } + return false; +} + +inline const core::type::Type* BuildLiteral(core::intrinsic::MatchState& state, + const core::type::Type*) { + return state.types.Get(); +} + inline bool MatchStructWithRuntimeArray(core::intrinsic::MatchState&, const core::type::Type* ty) { if (auto* str = ty->As()) { if (str->Members().IsEmpty()) { @@ -55,6 +70,42 @@ inline const core::type::Type* BuildStructWithRuntimeArray(core::intrinsic::Matc return ty; } +inline bool MatchStructAddCarryScalar(core::intrinsic::MatchState&, + const core::type::Type* ty, + const core::type::Type*& T) { + if (ty->Is()) { + T = ty; + return true; + } + return false; +} + +inline const core::type::Type* BuildStructAddCarryScalar(core::intrinsic::MatchState& state, + const core::type::Type*, + const core::type::Type* T) { + return core::type::CreateAddCarryResult(state.types, state.symbols, T); +} + +inline bool MatchStructAddCarryVec(core::intrinsic::MatchState&, + const core::type::Type* ty, + core::intrinsic::Number& N, + const core::type::Type*& T) { + if (ty->Is()) { + T = ty; + N = core::intrinsic::Number::any; + return true; + } + return false; +} + +inline const core::type::Type* BuildStructAddCarryVec(core::intrinsic::MatchState& state, + const core::type::Type*, + core::intrinsic::Number& N, + const core::type::Type* T) { + return core::type::CreateAddCarryResult(state.types, state.symbols, + state.types.vec(T, N.Value())); +} + inline bool MatchSampledImage(core::intrinsic::MatchState&, const core::type::Type* ty, const core::type::Type*& T) { diff --git a/3rdparty/dawn/src/tint/lang/spirv/ir/builtin_call.cc b/3rdparty/dawn/src/tint/lang/spirv/ir/builtin_call.cc index 4e35f210b..9f261d56c 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/ir/builtin_call.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/ir/builtin_call.cc @@ -49,13 +49,9 @@ BuiltinCall::~BuiltinCall() = default; BuiltinCall* BuiltinCall::Clone(core::ir::CloneContext& ctx) { auto* new_result = ctx.Clone(Result()); auto new_args = ctx.Clone(Args()); - auto new_explicit = ExplicitTemplateParams(); - - auto* inst = ctx.ir.CreateInstruction(new_result, func_, new_args); - if (!new_explicit.IsEmpty()) { - inst->SetExplicitTemplateParams(new_explicit); - } - return inst; + auto* cloned = ctx.ir.CreateInstruction(new_result, func_, new_args); + cloned->SetExplicitTemplateParams(ExplicitTemplateParams()); + return cloned; } tint::core::ir::Instruction::Accesses BuiltinCall::GetSideEffects() const { diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/common/options.h b/3rdparty/dawn/src/tint/lang/spirv/reader/common/options.h index 51149ff28..2d176e3b8 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/common/options.h +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/common/options.h @@ -31,7 +31,6 @@ #include #include "src/tint/api/common/binding_point.h" -#include "src/tint/lang/wgsl/allowed_features.h" namespace tint::spirv::reader { @@ -43,6 +42,12 @@ struct Options { /// If this map is empty, any binding conflicts will be automatically resolved by incrementing /// binding numbers until they are unique. std::unordered_map sampler_mappings{}; + + /// If true, dump the IR whenever validation is performed. + bool dump_ir_when_validating = false; + + /// If true, enable validation assertions. + bool enable_validation_asserts = false; }; } // namespace tint::spirv::reader diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/atomics.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/atomics.cc index f0d1aed17..a2620a476 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/atomics.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/atomics.cc @@ -423,7 +423,7 @@ struct State { const auto& args = uc->Args(); Vector to_convert; - for (size_t i = 0; i < args.Length(); ++i) { + for (size_t i = 0; i < args.size(); ++i) { if (params[i]->Type() != args[i]->Type()) { to_convert.Push(i); } @@ -554,14 +554,7 @@ struct State { } // namespace Result Atomics(core::ir::Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowPointerToHandle, - }, - "spirv.Atomics")); + AssertValid(ir, "before spirv.Atomics"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/builtins.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/builtins.cc index 1ebee0493..e62554220 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/builtins.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/builtins.cc @@ -1309,16 +1309,7 @@ struct State { } // namespace Result Builtins(core::ir::Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowStructMatrixDecorations, - core::ir::Capability::kAllowPointerToHandle, - }, - "spirv.Builtins")); + AssertValid(ir, "before spirv.Builtins"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_array.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_array.cc index 9aa27e3cd..dbaa5b949 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_array.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_array.cc @@ -251,15 +251,7 @@ struct State { } // namespace Result DecomposeStridedArray(core::ir::Module& ir) { - TINT_CHECK_RESULT( - core::ir::ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPointerToHandle, - }, - "spirv.DecomposeStridedArray")); + core::ir::AssertValid(ir, "before spirv.DecomposeStridedArray"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_matrix.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_matrix.cc index 6a8f6b52a..3cf9a68df 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_matrix.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/decompose_strided_matrix.cc @@ -362,19 +362,12 @@ struct State { } // namespace Result DecomposeStridedMatrix(core::ir::Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowStructMatrixDecorations, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPointerToHandle, - }, - "spirv.DecomposeStridedMatrix")); + AssertValid(ir, "before spirv.DecomposeStridedMatrix"); State{ir}.Process(); + ir.properties.Remove(core::ir::Property::kAllowStructMatrixDecorations); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/lower.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/lower.cc index 7cbbebcf8..a3e213171 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/lower.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/lower.cc @@ -65,13 +65,10 @@ Result Lower(core::ir::Module& mod) { // `||` statements. TINT_CHECK_RESULT(core::ir::transform::RemoveTerminatorArgs(mod)); - TINT_CHECK_RESULT( - core::ir::ValidateAfterIfNeeded(mod, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - }, - "spirv.Lower")); + // All SPIR-V types should have been removed by the transforms above. + mod.properties.Remove(core::ir::Property::kAllowNonCoreTypes); + + core::ir::AssertValid(mod, "after spirv.Lower"); return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/shader_io.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/shader_io.cc index 9161a2ac6..3933e4c6a 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/shader_io.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/shader_io.cc @@ -460,7 +460,7 @@ struct State { if (!chain) { continue; } - TINT_ASSERT(chain->Indices().Length() >= 1); + TINT_ASSERT(chain->Indices().size() >= 1); // A member access has to be a constant index auto* cnst = chain->Indices()[0]->As(); @@ -740,21 +740,18 @@ struct State { } // namespace Result ShaderIO(core::ir::Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPhonyInstructions, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowStructMatrixDecorations, - core::ir::Capability::kAllowLocationForNumericElements, - core::ir::Capability::kAllowPointerToHandle, - core::ir::Capability::kLoosenValidationForShaderIO, - }, - "spirv.ShaderIO")); + AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kLoosenValidationForShaderIO, + }, + "before spirv.ShaderIO"); - return State{ir}.Process(); + TINT_CHECK_RESULT(State{ir}.Process()); + + ir.properties.Remove(core::ir::Property::kAllowLocationForNumericComposites); + ir.properties.Remove(core::ir::Property::kAllowPointSizeBuiltin); + + return Success; } } // namespace tint::spirv::reader::lower diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/texture.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/texture.cc index 67910f0cd..260a0daad 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/texture.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/texture.cc @@ -27,7 +27,6 @@ #include "src/tint/lang/spirv/reader/lower/texture.h" -#include #include #include #include @@ -127,7 +126,8 @@ struct State { }); } - Vector depth_worklist; + std::vector> worklist; + worklist.reserve(128); for (auto* inst : ir.Instructions()) { if (auto* builtin = inst->As()) { switch (builtin->Func()) { @@ -135,11 +135,15 @@ struct State { SampledImage(builtin); break; case spirv::BuiltinFn::kImageDrefGather: + worklist.push_back( + [this, builtin] { FindVarsForImageGatherDref(builtin); }); + break; case spirv::BuiltinFn::kImageSampleDrefImplicitLod: case spirv::BuiltinFn::kImageSampleDrefExplicitLod: case spirv::BuiltinFn::kImageSampleProjDrefImplicitLod: case spirv::BuiltinFn::kImageSampleProjDrefExplicitLod: - depth_worklist.Push(builtin); + worklist.push_back( + [this, builtin] { FindVarsForImageSampleDref(builtin); }); break; default: break; @@ -150,21 +154,10 @@ struct State { // For each depth function, find the parameters which needed be converted. We don't convert // the actual calls yet, as we may need to parameters to have propagated through function // parameters. - for (auto* builtin : depth_worklist) { - switch (builtin->Func()) { - case spirv::BuiltinFn::kImageSampleDrefImplicitLod: - case spirv::BuiltinFn::kImageSampleDrefExplicitLod: - case spirv::BuiltinFn::kImageSampleProjDrefImplicitLod: - case spirv::BuiltinFn::kImageSampleProjDrefExplicitLod: - FindVarsForImageSampleDref(builtin); - break; - case spirv::BuiltinFn::kImageDrefGather: - FindVarsForImageGatherDref(builtin); - break; - default: - TINT_UNREACHABLE(); - } + for (auto& cb : worklist) { + cb(); } + worklist.clear(); Hashset converted{}; while (!textures_to_convert_to_depth_.IsEmpty()) { @@ -215,74 +208,54 @@ struct State { SampledImage(builtin); break; case spirv::BuiltinFn::kOpImage: + worklist.push_back([this, builtin] { Image(builtin); }); + break; case spirv::BuiltinFn::kImageRead: case spirv::BuiltinFn::kImageFetch: + worklist.push_back([this, builtin] { ImageFetch(builtin); }); + break; case spirv::BuiltinFn::kImageGather: + worklist.push_back([this, builtin] { ImageGather(builtin); }); + break; case spirv::BuiltinFn::kImageQueryLevels: + worklist.push_back([this, builtin] { + ImageQuery(builtin, core::BuiltinFn::kTextureNumLevels); + }); + break; case spirv::BuiltinFn::kImageQuerySamples: + worklist.push_back([this, builtin] { + ImageQuery(builtin, core::BuiltinFn::kTextureNumSamples); + }); + break; case spirv::BuiltinFn::kImageQuerySize: case spirv::BuiltinFn::kImageQuerySizeLod: + worklist.push_back([this, builtin] { ImageQuerySize(builtin); }); + break; case spirv::BuiltinFn::kImageSampleExplicitLod: case spirv::BuiltinFn::kImageSampleImplicitLod: case spirv::BuiltinFn::kImageSampleProjImplicitLod: case spirv::BuiltinFn::kImageSampleProjExplicitLod: + worklist.push_back([this, builtin] { ImageSample(builtin); }); + break; case spirv::BuiltinFn::kImageWrite: + worklist.push_back([this, builtin] { ImageWrite(builtin); }); + break; case spirv::BuiltinFn::kImageSampleDrefImplicitLod: case spirv::BuiltinFn::kImageSampleDrefExplicitLod: case spirv::BuiltinFn::kImageSampleProjDrefImplicitLod: case spirv::BuiltinFn::kImageSampleProjDrefExplicitLod: + worklist.push_back([this, builtin] { ImageSampleDref(builtin); }); + break; case spirv::BuiltinFn::kImageDrefGather: - builtin_worklist.Push(builtin); + worklist.push_back([this, builtin] { ImageGatherDref(builtin); }); break; default: TINT_UNREACHABLE() << "unknown spirv builtin: " << builtin->Func(); } } } - - for (auto* builtin : builtin_worklist) { - switch (builtin->Func()) { - case spirv::BuiltinFn::kOpImage: - Image(builtin); - break; - case spirv::BuiltinFn::kImageRead: - case spirv::BuiltinFn::kImageFetch: - ImageFetch(builtin); - break; - case spirv::BuiltinFn::kImageGather: - ImageGather(builtin); - break; - case spirv::BuiltinFn::kImageQueryLevels: - ImageQuery(builtin, core::BuiltinFn::kTextureNumLevels); - break; - case spirv::BuiltinFn::kImageQuerySamples: - ImageQuery(builtin, core::BuiltinFn::kTextureNumSamples); - break; - case spirv::BuiltinFn::kImageQuerySize: - case spirv::BuiltinFn::kImageQuerySizeLod: - ImageQuerySize(builtin); - break; - case spirv::BuiltinFn::kImageSampleExplicitLod: - case spirv::BuiltinFn::kImageSampleImplicitLod: - case spirv::BuiltinFn::kImageSampleProjImplicitLod: - case spirv::BuiltinFn::kImageSampleProjExplicitLod: - ImageSample(builtin); - break; - case spirv::BuiltinFn::kImageWrite: - ImageWrite(builtin); - break; - case spirv::BuiltinFn::kImageSampleDrefImplicitLod: - case spirv::BuiltinFn::kImageSampleDrefExplicitLod: - case spirv::BuiltinFn::kImageSampleProjDrefImplicitLod: - case spirv::BuiltinFn::kImageSampleProjDrefExplicitLod: - ImageSampleDref(builtin); - break; - case spirv::BuiltinFn::kImageDrefGather: - ImageGatherDref(builtin); - break; - default: - TINT_UNREACHABLE(); - } + for (auto& cb : worklist) { + cb(); } // Destroy all the OpSampledImage instructions. @@ -339,7 +312,7 @@ struct State { } auto args = call->Args(); - for (size_t i = 0; i < args.Length(); ++i) { + for (size_t i = 0; i < args.size(); ++i) { auto& arg = args[i]; auto* ptr_ty = arg->Type()->As(); @@ -511,7 +484,7 @@ struct State { const auto& args = uc->Args(); Vector to_convert; - for (size_t i = 0; i < args.Length(); ++i) { + for (size_t i = 0; i < args.size(); ++i) { if (params[i]->Type() != args[i]->Type()) { to_convert.Push(i); } @@ -1114,17 +1087,12 @@ struct State { } // namespace Result Texture(core::ir::Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowPointerToHandle, - }, - "spirv.Texture")); + AssertValid(ir, "before spirv.Texture"); State{ir}.Process(); + ir.properties.Remove(core::ir::Property::kAllowPointerToHandle); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/transpose_row_major.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/transpose_row_major.cc index d188de472..3ffa71623 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/transpose_row_major.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/transpose_row_major.cc @@ -27,6 +27,7 @@ #include "src/tint/lang/spirv/reader/lower/transpose_row_major.h" +#include #include #include "src/tint/lang/core/ir/builder.h" @@ -44,18 +45,10 @@ constexpr std::string_view kTintLoadRowMajor = "tint_load_row_major_column"; constexpr std::string_view kTintTransposeRowMajorArray = "tint_transpose_row_major_array"; constexpr std::string_view kTintStoreRowMajor = "tint_store_row_major_column"; -/// PIMPL state for the transform. struct State { - /// The IR module. core::ir::Module& ir; - - /// The IR builder. core::ir::Builder b{ir}; - - /// The type manager. core::type::Manager& ty{ir.Types()}; - - /// The symbol manager. SymbolTable& sym{ir.symbols}; // A map from a (type, is_row_major) pair to it's replacement (which maybe the same as the @@ -93,6 +86,9 @@ struct State { /// Instructions which have been processed Hashset processed_instructions{}; + /// Results with the type replaced + std::unordered_set replaced_result_types{}; + /// Process the module. void Process() { Vector instructions_to_process; @@ -180,18 +176,26 @@ struct State { return; } + const core::type::Struct* new_struct_ty = + RewriteType(struct_type, false)->As(); + + const core::type::Struct* original_ty = struct_to_original.GetOr(new_struct_ty, nullptr); + if (original_ty == nullptr) { + return; + } + b.InsertBefore(construct, [&] { Vector new_operands; for (uint32_t i = 0; i < construct->Operands().Length(); i++) { auto* operand = construct->Operands()[i]; - auto* member_type = struct_type->Members()[i]->Type(); - if (member_type != operand->Type()) { + auto* member_type = original_ty->Members()[i]->Type(); + if (member_type != operand->Type() || original_ty->Members()[i]->RowMajor()) { tint::Switch( member_type, [&](const core::type::Matrix*) { - new_operands.Push( - b.Call(member_type, core::BuiltinFn::kTranspose, operand) - ->Result()); + new_operands.Push(b.Call(new_struct_ty->Members()[i]->Type(), + core::BuiltinFn::kTranspose, operand) + ->Result()); }, [&](const core::type::Array*) { // TODO(437140112): Add support for arrays of matrices @@ -279,7 +283,7 @@ struct State { const core::type::Matrix* mat_ty = nullptr; auto indices = access->Indices(); int32_t matrix_index = -1; - for (uint32_t i = 0; i < indices.Length(); ++i) { + for (uint32_t i = 0; i < indices.size(); ++i) { auto* idx = indices[i]; if (auto* struct_ty = cur_ty->As()) { @@ -321,7 +325,8 @@ struct State { } // The thing we're accessing has changed, so we need to change. - if (!indexed_through_row_major && cur_ty != access->Result()->Type()->UnwrapPtr()) { + if (!indexed_through_row_major && (replaced_result_types.contains(access->Object()) || + cur_ty != access->Result()->Type()->UnwrapPtr())) { ReplacePointerAccess(access, parent_ty, cur_ty); return; } @@ -345,15 +350,16 @@ struct State { // This isn't a pointer access, so we'll just split the access in half, transpose the // matrix itself and then access that matrix with the rest of the expression. - Vector mat_indices = indices.Truncate(size_t(matrix_index) + 1); + auto mat_indices = + Vector{indices.subspan(0, static_cast(matrix_index) + 1)}; b.InsertBefore(access, [&] { auto* m = b.Access(mat_ty, access->Object(), mat_indices); auto* t = b.Call(RewriteType(mat_ty, true), core::BuiltinFn::kTranspose, m)->Result(); - if (uint32_t(matrix_index) != indices.Length() - 1) { - Vector access_indices = - indices.Offset(size_t(matrix_index) + 1); + if (static_cast(matrix_index) != indices.size() - 1) { + auto access_indices = Vector{ + indices.subspan(static_cast(matrix_index) + 1)}; b.AccessWithResult(access->DetachResult(), t, access_indices)->Result(); } else { access->Result()->ReplaceAllUsesWith(t); @@ -369,10 +375,9 @@ struct State { // the access result type, and if changed, update the uses of this access if (cur_ty->Is() || cur_ty->Is()) { auto* new_access_ty = RewriteType(access->Result()->Type(), true); - if (new_access_ty != access->Result()->Type()) { - access->Result()->SetType(new_access_ty); - results_to_update.Push(access->Result()); - } + access->Result()->SetType(new_access_ty); + replaced_result_types.insert(access->Result()); + results_to_update.Push(access->Result()); return; } @@ -389,6 +394,7 @@ struct State { new_access_ty = ty.ptr(access_ptr->AddressSpace(), parent_ty, access_ptr->Access()); } access->Result()->SetType(new_access_ty); + replaced_result_types.insert(access->Result()); access_to_vector_index.Add(access->Result(), idx); results_to_update.Push(access->Result()); @@ -633,7 +639,7 @@ struct State { const core::type::Type* RewriteArray(const core::type::Array* arr, bool decorated_row_major) { auto* elem_ty = RewriteType(arr->ElemType(), decorated_row_major); - if (elem_ty == arr->ElemType()) { + if (!decorated_row_major && elem_ty == arr->ElemType()) { return arr; } @@ -683,7 +689,7 @@ struct State { bool is_row_major) { auto* orig_type = constant->Type(); auto* new_type = RewriteType(orig_type, is_row_major); - if (new_type == orig_type) { + if (!is_row_major && new_type == orig_type) { return constant; } @@ -728,6 +734,11 @@ struct State { [&](const core::type::Struct* str) { TINT_ASSERT(constant->NumElements() == str->Members().Length()); + auto* original_ty = struct_to_original.GetOr(str, nullptr); + if (original_ty == nullptr) { + return constant; + } + Vector elements; elements.Reserve(str->Members().Length()); @@ -740,7 +751,7 @@ struct State { auto* value = constant->Index(i); auto* new_member_type = new_mem->Type(); - if (new_member_type != value->Type()) { + if (new_member_type != value->Type() || original_ty->Members()[i]->RowMajor()) { elements.Push(RewriteConstant(value, orig_mem->RowMajor())); } else { elements.Push(value); @@ -755,16 +766,7 @@ struct State { } // namespace Result TransposeRowMajor(core::ir::Module& ir) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowStructMatrixDecorations, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPointerToHandle, - }, - "spirv.TransposeRowMajor")); + AssertValid(ir, "before spirv.TransposeRowMajor"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/vector_element_pointer.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/vector_element_pointer.cc index 55694c441..e472c71ff 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/lower/vector_element_pointer.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/lower/vector_element_pointer.cc @@ -98,9 +98,9 @@ struct State { void ReplaceAccess(const Access& access) { auto* object = access.inst->Object(); - if (access.inst->Indices().Length() > 1) { + if (access.inst->Indices().size() > 1) { // Create a new access instruction that stops at the vector pointer. - Vector partial_indices{access.inst->Indices()}; + auto partial_indices = Vector{access.inst->Indices()}; partial_indices.Pop(); auto* ptr = object->Type()->As(); @@ -113,7 +113,7 @@ struct State { } // Replace all uses of the original access instruction. - auto* index = access.inst->Indices().Back(); + auto* index = access.inst->Indices().back(); ReplaceAccessUses(access.inst, object, index); // Destroy the original access instruction. @@ -154,23 +154,16 @@ struct State { } // namespace Result VectorElementPointer(core::ir::Module& ir) { - TINT_CHECK_RESULT( - core::ir::ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowVectorElementPointer, - core::ir::Capability::kAllowPhonyInstructions, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllowStructMatrixDecorations, - core::ir::Capability::kAllowLocationForNumericElements, - core::ir::Capability::kAllowPointerToHandle, - core::ir::Capability::kLoosenValidationForShaderIO, - }, - "spirv.VectorElementPointer")); + core::ir::AssertValid(ir, + core::ir::Capabilities{ + core::ir::Capability::kLoosenValidationForShaderIO, + }, + "before spirv.VectorElementPointer"); State{ir}.Process(); + ir.properties.Remove(core::ir::Property::kAllowVectorElementPointer); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.cc index 56314a23e..2bb9ca300 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.cc @@ -31,6 +31,7 @@ #include #include #include +#include #include #include #include @@ -46,9 +47,11 @@ TINT_BEGIN_DISABLE_WARNING(OLD_STYLE_CAST); TINT_BEGIN_DISABLE_WARNING(SIGN_CONVERSION); TINT_BEGIN_DISABLE_WARNING(WEAK_VTABLES); TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +TINT_BEGIN_DISABLE_WARNING(LIFETIME_SAFETY_INVALIDATION); #include "source/opt/build_module.h" #include "source/opt/resolve_binding_conflicts_pass.h" #include "source/opt/split_combined_image_sampler_pass.h" +TINT_END_DISABLE_WARNING(LIFETIME_SAFETY_INVALIDATION); TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); TINT_END_DISABLE_WARNING(WEAK_VTABLES); TINT_END_DISABLE_WARNING(SIGN_CONVERSION); @@ -63,6 +66,7 @@ TINT_END_DISABLE_WARNING(NEWLINE_EOF); #include "src/tint/lang/spirv/ir/builtin_call.h" #include "src/tint/lang/spirv/type/explicit_layout_array.h" #include "src/tint/lang/spirv/type/image.h" +#include "src/tint/lang/spirv/type/literal.h" #include "src/tint/lang/spirv/type/sampled_image.h" #include "src/tint/lang/spirv/validate/validate.h" @@ -97,14 +101,18 @@ class Parser { /// @param spirv the SPIR-V binary data /// @returns the generated SPIR-V IR module on success, or failure - Result Run(Slice spirv) { + Result Run(std::span spirv) { // Validate the incoming SPIR-V binary. - TINT_CHECK_RESULT(validate::Validate(spirv, kTargetEnv)); + validate::Options options{ + .target_env = kTargetEnv, + .uniform_buffer_standard_layout = true, + }; + TINT_CHECK_RESULT(validate::Validate(spirv, options)); // Build the SPIR-V tools internal representation of the SPIR-V module. spvtools::Context context(kTargetEnv); - spirv_context_ = - spvtools::BuildModule(kTargetEnv, context.CContext()->consumer, spirv.data, spirv.len); + spirv_context_ = spvtools::BuildModule(kTargetEnv, context.CContext()->consumer, + spirv.data(), spirv.size()); if (!spirv_context_) { return Failure("failed to build the internal representation of the module"); } @@ -140,6 +148,29 @@ class Parser { } } + // Check for unsupported types. + for (const auto& type : *spirv_context_->get_type_mgr()) { + switch (type.second->kind()) { + case spvtools::opt::analysis::Type::kArray: { + auto kind = type.second->AsArray()->element_type()->kind(); + if (kind == spvtools::opt::analysis::Type::kImage || + kind == spvtools::opt::analysis::Type::kSampler) { + return Failure("arrays of handle types are not supported"); + } + break; + } + case spvtools::opt::analysis::Type::kImage: { + auto* img = type.second->AsImage(); + if (img->is_arrayed() && img->is_multisampled()) { + return Failure("arrayed multisampled images are not supported"); + } + break; + } + default: + break; + } + } + // Register imported instruction sets for (const auto& import : spirv_context_->ext_inst_imports()) { auto name = import.GetInOperand(0).AsString(); @@ -153,6 +184,18 @@ class Parser { } } + // Set properties that are supported by the SPIR-V parser. + ir_.properties.Add(core::ir::Property::kAllowLocationForNumericComposites); + ir_.properties.Add(core::ir::Property::kAllowMultipleEntryPoints); + ir_.properties.Add(core::ir::Property::kAllowNonCoreTypes); + ir_.properties.Add(core::ir::Property::kAllowOverrides); + ir_.properties.Add(core::ir::Property::kAllowPhonyInstructions); + ir_.properties.Add(core::ir::Property::kAllowPointSizeBuiltin); + ir_.properties.Add(core::ir::Property::kAllowPointerToHandle); + ir_.properties.Add(core::ir::Property::kAllowStructMatrixDecorations); + ir_.properties.Add(core::ir::Property::kAllowUnannotatedModuleIOVariables); + ir_.properties.Add(core::ir::Property::kAllowVectorElementPointer); + RegisterNames(); id_stack_.emplace_back(); @@ -1406,15 +1449,32 @@ class Parser { return *v; } - if (auto* c = SpvConstant(id)) { - auto* val = b_.Constant(Constant(c)); + const spvtools::opt::Instruction* inst = spirv_context_->get_def_use_mgr()->GetDef(id); + const core::type::Type* inst_ty = Type(inst->type_id()); + + if (const spvtools::opt::analysis::Constant* c = SpvConstant(id)) { + core::ir::Constant* val = b_.Constant(Constant(c)); + // SPIR-V opt will deduplicate structs with the same shape. We handle this in the type + // code below by using the specific instructions type, not the spirv-opt type. But, when + // we retrieve constants, then opt might have used the other type for the struct type. + // So, check the instructions type, if it doesn't match what opt returns, then we + // rebuild the struct below with our corrected type. + if (val->Type() == inst_ty) { + values_.Add(id, val); + return val; + } + } + + // In the case of a deduplicated structure, we may need to re-create a null constant + if (inst->opcode() == spv::Op::OpConstantNull) { + TINT_ASSERT(inst_ty->Is()); + core::ir::Value* val = b_.Zero(inst_ty); values_.Add(id, val); return val; } // If we didn't have a value already, and this instruction is a constructed constant, then // do the construction. - const spvtools::opt::Instruction* inst = spirv_context_->get_def_use_mgr()->GetDef(id); if (inst->opcode() == spv::Op::OpConstantComposite) { Vector args; args.Reserve(inst->NumInOperands()); @@ -1425,7 +1485,7 @@ class Parser { args.Push(cnst->Value()); } - auto* composite = b_.Composite(Type(inst->type_id()), args); + auto* composite = b_.Composite(inst_ty, args); AddValue(id, composite); return composite; } @@ -1536,6 +1596,12 @@ class Parser { TINT_UNIMPLEMENTED() << "unhandled constant type"; } + /// @returns a literal operand with the given value + core::ir::Value* Literal(uint32_t value) { + return b_.Constant(ir_.constant_values.Get>( + ty_.Get(), u32(value))); + } + /// Register an IR value for a SPIR-V result ID. /// @param result_id the SPIR-V result ID /// @param value the IR value @@ -1847,7 +1913,7 @@ class Parser { for (auto incoming : loop->Continuing()->InboundSiblingBranches()) { TINT_ASSERT(incoming->Is()); - if (incoming->Args().Length() == loop->Continuing()->Params().Length()) { + if (incoming->Args().size() == loop->Continuing()->Params().Length()) { continue; } @@ -3105,7 +3171,9 @@ class Parser { auto* si = Value(inst.GetSingleWordInOperand(0)); Emit(b_.CallExplicit( Type(inst.type_id()), spirv::BuiltinFn::kOpImage, - Vector{si->Type()->As()->Image()}, Args(inst, 2)), + Vector{ + si->Type()->As()->Image()}, + Args(inst, 2)), inst.result_id()); } @@ -3115,9 +3183,9 @@ class Parser { TINT_ASSERT(img_type); TINT_ASSERT(img_type->GetMultisampled() != type::Multisampled::kMultisampled) << "Creating an OpTypeSampledImage from a multisampled image is not supported"; - Emit(b_.CallExplicit(Type(inst.type_id()), - spirv::BuiltinFn::kOpSampledImage, - Vector{tex->Type()}, Args(inst, 2)), + Emit(b_.CallExplicit( + Type(inst.type_id()), spirv::BuiltinFn::kOpSampledImage, + Vector{tex->Type()}, Args(inst, 2)), inst.result_id()); } @@ -3127,15 +3195,10 @@ class Parser { Vector args = {sampled_image, coord}; - if (inst.NumInOperands() > 2) { - uint32_t literal_mask = inst.GetSingleWordInOperand(2); - args.Push(b_.Constant(u32(literal_mask))); - - if (literal_mask != 0) { - args.Push(Value(inst.GetSingleWordInOperand(3))); - } - } else { - args.Push(b_.Zero(ty_.u32())); + uint32_t literal_mask = inst.NumInOperands() > 2 ? inst.GetSingleWordInOperand(2) : 0u; + args.Push(Literal(literal_mask)); + if (literal_mask != 0) { + args.Push(Value(inst.GetSingleWordInOperand(3))); } Emit(b_.Call(Type(inst.type_id()), fn, args), inst.result_id()); @@ -3148,18 +3211,13 @@ class Parser { Vector args = {sampled_image, coord, dref}; - if (inst.NumInOperands() > 3) { - uint32_t literal_mask = inst.GetSingleWordInOperand(3); - args.Push(b_.Constant(u32(literal_mask))); - - if (literal_mask != 0) { - TINT_ASSERT(static_cast(literal_mask) == - spv::ImageOperandsMask::ConstOffset); - TINT_ASSERT(inst.NumInOperands() > 4); - args.Push(Value(inst.GetSingleWordInOperand(4))); - } - } else { - args.Push(b_.Zero(ty_.u32())); + uint32_t literal_mask = inst.NumInOperands() > 3 ? inst.GetSingleWordInOperand(3) : 0u; + args.Push(Literal(literal_mask)); + if (literal_mask != 0) { + TINT_ASSERT(static_cast(literal_mask) == + spv::ImageOperandsMask::ConstOffset); + TINT_ASSERT(inst.NumInOperands() > 4); + args.Push(Value(inst.GetSingleWordInOperand(4))); } Emit(b_.Call(Type(inst.type_id()), @@ -3174,18 +3232,13 @@ class Parser { Vector args = {sampled_image, coord, comp}; - if (inst.NumInOperands() > 3) { - uint32_t literal_mask = inst.GetSingleWordInOperand(3); - args.Push(b_.Constant(u32(literal_mask))); - - if (literal_mask != 0) { - TINT_ASSERT(static_cast(literal_mask) == - spv::ImageOperandsMask::ConstOffset); - TINT_ASSERT(inst.NumInOperands() > 4); - args.Push(Value(inst.GetSingleWordInOperand(4))); - } - } else { - args.Push(b_.Zero(ty_.u32())); + uint32_t literal_mask = inst.NumInOperands() > 3 ? inst.GetSingleWordInOperand(3) : 0u; + args.Push(Literal(literal_mask)); + if (literal_mask != 0) { + TINT_ASSERT(static_cast(literal_mask) == + spv::ImageOperandsMask::ConstOffset); + TINT_ASSERT(inst.NumInOperands() > 4); + args.Push(Value(inst.GetSingleWordInOperand(4))); } Emit(b_.Call(Type(inst.type_id()), spirv::BuiltinFn::kImageGather, @@ -3199,19 +3252,11 @@ class Parser { Vector args = {sampled_image, coord}; - if (inst.NumInOperands() > 2) { - uint32_t literal_mask = inst.GetSingleWordInOperand(2); - args.Push(b_.Constant(u32(literal_mask))); - - if (literal_mask != 0) { - TINT_ASSERT(inst.NumInOperands() > 3); - } - - for (uint32_t i = 3; i < inst.NumInOperands(); ++i) { - args.Push(Value(inst.GetSingleWordInOperand(i))); - } - } else { - args.Push(b_.Zero(ty_.u32())); + uint32_t literal_mask = inst.NumInOperands() > 2 ? inst.GetSingleWordInOperand(2) : 0u; + args.Push(Literal(literal_mask)); + TINT_ASSERT(literal_mask == 0 || inst.NumInOperands() > 3); + for (uint32_t i = 3; i < inst.NumInOperands(); ++i) { + args.Push(Value(inst.GetSingleWordInOperand(i))); } Emit(b_.Call(Type(inst.type_id()), fn, args), inst.result_id()); @@ -3228,28 +3273,20 @@ class Parser { Vector args = {sampled_image, coord, dref}; - if (inst.NumInOperands() > 3) { - uint32_t literal_mask = inst.GetSingleWordInOperand(3); - args.Push(b_.Constant(u32(literal_mask))); + uint32_t literal_mask = inst.NumInOperands() > 3 ? inst.GetSingleWordInOperand(3) : 0u; + args.Push(Literal(literal_mask)); + TINT_ASSERT(literal_mask == 0 || inst.NumInOperands() > 4); + for (uint32_t i = 4; i < inst.NumInOperands(); ++i) { + args.Push(Value(inst.GetSingleWordInOperand(i))); + } - if (literal_mask != 0) { - TINT_ASSERT(inst.NumInOperands() > 4); - } + if (HasLod(literal_mask)) { + core::ir::Value* lod = args[4]; + TINT_ASSERT(lod->Is()); + TINT_ASSERT(lod->Type()->As()); - for (uint32_t i = 4; i < inst.NumInOperands(); ++i) { - args.Push(Value(inst.GetSingleWordInOperand(i))); - } - - if (HasLod(literal_mask)) { - core::ir::Value* lod = args[4]; - TINT_ASSERT(lod->Is()); - TINT_ASSERT(lod->Type()->As()); - - auto v = lod->As()->Value()->ValueAs(); - TINT_ASSERT(v == 0.0f) << "Dref LOD values must be 0.0"; - } - } else { - args.Push(b_.Zero(ty_.u32())); + auto v = lod->As()->Value()->ValueAs(); + TINT_ASSERT(v == 0.0f) << "Dref LOD values must be 0.0"; } Emit(b_.Call(Type(inst.type_id()), fn, args), inst.result_id()); @@ -3283,15 +3320,9 @@ class Parser { } } - Vector args = {image, coord, texel}; - if (inst.NumInOperands() > 3) { - uint32_t literal_mask = inst.GetSingleWordInOperand(3); - args.Push(b_.Constant(u32(literal_mask))); - TINT_ASSERT(literal_mask == 0); - } else { - args.Push(b_.Zero(ty_.u32())); - } - + uint32_t literal_mask = inst.NumInOperands() > 3 ? inst.GetSingleWordInOperand(3) : 0u; + TINT_ASSERT(literal_mask == 0); + Vector args = {image, coord, texel, Literal(literal_mask)}; Emit(b_.Call(ty_.void_(), spirv::BuiltinFn::kImageWrite, args), inst.result_id()); } @@ -3300,7 +3331,8 @@ class Parser { auto* image = Value(inst.GetSingleWordInOperand(0)); auto* ty = Type(inst.type_id()); - Emit(b_.CallExplicit(ty, fn, Vector{ty->DeepestElement()}, image), + Emit(b_.CallExplicit( + ty, fn, Vector{ty->DeepestElement()}, image), inst.result_id()); } @@ -3309,8 +3341,9 @@ class Parser { auto* level = Value(inst.GetSingleWordInOperand(1)); auto* ty = Type(inst.type_id()); - Emit(b_.CallExplicit(ty, spirv::BuiltinFn::kImageQuerySizeLod, - Vector{ty->DeepestElement()}, image, level), + Emit(b_.CallExplicit( + ty, spirv::BuiltinFn::kImageQuerySizeLod, + Vector{ty->DeepestElement()}, image, level), inst.result_id()); } @@ -3806,8 +3839,8 @@ class Parser { default_blk->Append(b_.ExitSwitch(switch_)); } - std::unordered_map block_id_to_case; - block_id_to_case[default_id] = &(switch_->Cases().Back()); + std::unordered_map block_id_to_case_index; + block_id_to_case_index[default_id] = switch_->Cases().Length() - 1; for (uint32_t i = 2; i < inst.NumInOperandWords(); i += 2) { auto blk_id = inst.GetSingleWordInOperand(i + 1); @@ -3830,9 +3863,10 @@ class Parser { } // Determine if we've seen this block and should combine selectors - auto iter = block_id_to_case.find(blk_id); - if (iter != block_id_to_case.end()) { - iter->second->selectors.Push(core::ir::Switch::CaseSelector{sel}); + auto case_index_iter = block_id_to_case_index.find(blk_id); + if (case_index_iter != block_id_to_case_index.end()) { + switch_->Cases()[case_index_iter->second].selectors.Push( + core::ir::Switch::CaseSelector{sel}); continue; } @@ -3844,7 +3878,7 @@ class Parser { if (!blk->Terminator()) { blk->Append(b_.ExitSwitch(switch_)); } - block_id_to_case[blk_id] = &(switch_->Cases().Back()); + block_id_to_case_index[blk_id] = switch_->Cases().Length() - 1; } current_switch_blocks_.pop_back(); @@ -3868,9 +3902,10 @@ class Parser { void EmitSpirvExplicitBuiltinCall(const spvtools::opt::Instruction& inst, spirv::BuiltinFn fn, uint32_t first_operand_idx = 2) { - Emit(b_.CallExplicit(Type(inst.type_id()), fn, - Vector{Type(inst.type_id())->DeepestElement()}, - Args(inst, first_operand_idx)), + Emit(b_.CallExplicit( + Type(inst.type_id()), fn, + Vector{Type(inst.type_id())->DeepestElement()}, + Args(inst, first_operand_idx)), inst.result_id()); } @@ -3884,9 +3919,9 @@ class Parser { void EmitBitCount(const spvtools::opt::Instruction& inst) { auto* res_ty = Type(inst.type_id()); - Emit(b_.CallExplicit(res_ty, spirv::BuiltinFn::kBitCount, - Vector{res_ty->DeepestElement()}, - Args(inst, 2)), + Emit(b_.CallExplicit( + res_ty, spirv::BuiltinFn::kBitCount, + Vector{res_ty->DeepestElement()}, Args(inst, 2)), inst.result_id()); } @@ -4115,8 +4150,9 @@ class Parser { return spirv::BuiltinFn::kNone; } - Vector GlslStd450ExplicitParams(uint32_t ext_opcode, - const core::type::Type* result_ty) { + Vector GlslStd450ExplicitParams( + uint32_t ext_opcode, + const core::type::Type* result_ty) { if (ext_opcode == GLSLstd450SSign || ext_opcode == GLSLstd450SAbs || ext_opcode == GLSLstd450SMax || ext_opcode == GLSLstd450SMin || ext_opcode == GLSLstd450SClamp || ext_opcode == GLSLstd450UMax || @@ -4650,7 +4686,7 @@ class Parser { } // namespace -Result Parse(Slice spirv, const Options& options) { +Result Parse(std::span spirv, const Options& options) { return Parser(options).Run(spirv); } diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.h b/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.h index 02a92c39e..ef2cee577 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.h +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/parser/parser.h @@ -29,9 +29,9 @@ #define SRC_TINT_LANG_SPIRV_READER_PARSER_PARSER_H_ #include +#include #include "src/tint/lang/spirv/reader/common/options.h" -#include "src/tint/utils/containers/slice.h" #include "src/tint/utils/result.h" // Forward declarations @@ -45,7 +45,7 @@ namespace tint::spirv::reader { /// @param spirv the SPIR-V binary data /// @param options the parser options /// @returns the SPIR-V IR module on success, or failure -Result Parse(Slice spirv, const Options& options = {}); +Result Parse(std::span spirv, const Options& options = {}); } // namespace tint::spirv::reader diff --git a/3rdparty/dawn/src/tint/lang/spirv/reader/reader.cc b/3rdparty/dawn/src/tint/lang/spirv/reader/reader.cc index 1f0fbb485..ae6037001 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/reader/reader.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/reader/reader.cc @@ -27,6 +27,8 @@ #include "src/tint/lang/spirv/reader/reader.h" +#include + #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/validator.h" #include "src/tint/lang/spirv/reader/lower/lower.h" @@ -36,19 +38,16 @@ namespace tint::spirv::reader { Result ReadIR(const std::vector& input, const Options& options) { // Parse the input SPIR-V to the SPIR-V dialect of the IR. - TINT_CHECK_RESULT_UNWRAP(mod, Parse(Slice(input.data(), input.size()), options)); + TINT_CHECK_RESULT_UNWRAP(mod, Parse(input, options)); + mod.dump_ir_when_validating = options.dump_ir_when_validating; + mod.enable_validation_asserts = options.enable_validation_asserts; // Lower the module to the core dialect of the IR. TINT_CHECK_RESULT(Lower(mod)); // Always validate the core IR, so that we fail somewhat gracefully on invalid inputs instead of // just ICEing later on. - TINT_CHECK_RESULT(core::ir::ValidateAfter(mod, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - }, - "spirv::ReadIR")); + TINT_CHECK_RESULT(core::ir::Validate(mod, "after spirv::ReadIR")); return mod; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/type/literal.cc b/3rdparty/dawn/src/tint/lang/spirv/type/literal.cc new file mode 100644 index 000000000..9d3ba89e0 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/spirv/type/literal.cc @@ -0,0 +1,59 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/tint/lang/spirv/type/literal.h" + +#include +#include + +#include "src/tint/lang/core/type/clone_context.h" +#include "src/tint/lang/core/type/manager.h" +#include "src/tint/lang/core/type/unique_node.h" +#include "src/tint/utils/math/hash.h" +#include "src/tint/utils/rtti/castable.h" + +TINT_INSTANTIATE_TYPEINFO(tint::spirv::type::Literal); + +namespace tint::spirv::type { + +Literal::Literal() + : Base(static_cast(Hash(tint::TypeCode::Of().bits)), + core::type::Flags{core::type::kConstructable, core::type::kCreationFixedFootprint}) {} + +bool Literal::Equals(const UniqueNode& other) const { + return other.Is(); +} + +std::string Literal::FriendlyName() const { + return "spirv.literal"; +} + +Literal* Literal::Clone(core::type::CloneContext& ctx) const { + return ctx.dst.mgr->Get(); +} + +} // namespace tint::spirv::type diff --git a/3rdparty/dawn/src/tint/lang/spirv/type/literal.h b/3rdparty/dawn/src/tint/lang/spirv/type/literal.h new file mode 100644 index 000000000..f4f6f3b08 --- /dev/null +++ b/3rdparty/dawn/src/tint/lang/spirv/type/literal.h @@ -0,0 +1,57 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_LANG_SPIRV_TYPE_LITERAL_H_ +#define SRC_TINT_LANG_SPIRV_TYPE_LITERAL_H_ + +#include + +#include "src/tint/lang/core/type/type.h" + +namespace tint::spirv::type { + +/// Literal represents a literal operand in SPIR-V. +class Literal final : public Castable { + public: + /// Constructor + Literal(); + + /// @param other the other node to compare against + /// @returns true if the this type is equal to @p other + bool Equals(const UniqueNode& other) const override; + + /// @returns the friendly name for this type + std::string FriendlyName() const override; + + /// @param ctx the clone context + /// @returns a clone of this type + Literal* Clone(core::type::CloneContext& ctx) const override; +}; + +} // namespace tint::spirv::type + +#endif // SRC_TINT_LANG_SPIRV_TYPE_LITERAL_H_ diff --git a/3rdparty/dawn/src/tint/lang/spirv/validate/validate.cc b/3rdparty/dawn/src/tint/lang/spirv/validate/validate.cc index 237e1259d..ed3745700 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/validate/validate.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/validate/validate.cc @@ -28,6 +28,7 @@ #include "src/tint/lang/spirv/validate/validate.h" #include +#include #include #include @@ -36,11 +37,11 @@ namespace tint::spirv::validate { -Result Validate(Slice spirv, spv_target_env target_env) { +Result Validate(std::span spirv, const Options& options) { Vector diags; diags.Push(diag::Diagnostic{}); // Filled in on error - spvtools::SpirvTools tools(target_env); + spvtools::SpirvTools tools(options.target_env); tools.SetMessageConsumer( [&](spv_message_level_t level, const char*, const spv_position_t& pos, const char* msg) { diag::Diagnostic diag; @@ -69,14 +70,15 @@ Result Validate(Slice spirv, spv_target_env target_ // time by scanning the whole module and building a string table. spvtools::ValidatorOptions val_opts; val_opts.SetFriendlyNames(false); + val_opts.SetUniformBufferStandardLayout(options.uniform_buffer_standard_layout); - if (tools.Validate(spirv.data, spirv.len, val_opts)) { + if (tools.Validate(spirv.data(), spirv.size(), val_opts)) { return Success; } std::string disassembly; if (tools.Disassemble( - spirv.data, spirv.len, &disassembly, + spirv.data(), spirv.size(), &disassembly, SPV_BINARY_TO_TEXT_OPTION_INDENT | SPV_BINARY_TO_TEXT_OPTION_FRIENDLY_NAMES)) { diag::Diagnostic& err = diags.Front(); err.message = "SPIR-V failed validation.\n\nDisassembly:\n" + std::move(disassembly); diff --git a/3rdparty/dawn/src/tint/lang/spirv/validate/validate.h b/3rdparty/dawn/src/tint/lang/spirv/validate/validate.h index 6e88423a3..fe968e7f7 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/validate/validate.h +++ b/3rdparty/dawn/src/tint/lang/spirv/validate/validate.h @@ -28,17 +28,24 @@ #ifndef SRC_TINT_LANG_SPIRV_VALIDATE_VALIDATE_H_ #define SRC_TINT_LANG_SPIRV_VALIDATE_VALIDATE_H_ +#include + #include "spirv-tools/libspirv.hpp" -#include "src/tint/utils/containers/slice.h" #include "src/tint/utils/result.h" namespace tint::spirv::validate { +/// The options to pass to the validator. +struct Options { + spv_target_env target_env = SPV_ENV_MAX; + bool uniform_buffer_standard_layout = false; +}; + /// Validate checks that the provided SPIR-V passes validation. /// @param spirv the SPIR-V binary data -/// @param target_env the target environment to validate against +/// @param options the options to use when validating /// @return success or failure(s) -Result Validate(Slice spirv, spv_target_env target_env); +Result Validate(std::span spirv, const Options& options); } // namespace tint::spirv::validate diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/analysis/relaxed_precision_decorations.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/analysis/relaxed_precision_decorations.cc index 7cceef020..603d2ebd7 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/analysis/relaxed_precision_decorations.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/analysis/relaxed_precision_decorations.cc @@ -31,6 +31,7 @@ #include "src/tint/lang/core/ir/let.h" #include "src/tint/lang/core/ir/load.h" #include "src/tint/lang/core/ir/module.h" +#include "src/tint/lang/core/ir/swizzle.h" #include "src/tint/lang/core/ir/user_call.h" #include "src/tint/lang/core/ir/var.h" #include "src/tint/lang/core/type/f16.h" @@ -203,11 +204,7 @@ struct State { case BuiltinFn::kImageSampleProjDrefExplicitLod: case BuiltinFn::kImageSampleDrefImplicitLod: case BuiltinFn::kImageSampleDrefExplicitLod: { - if (IsConvertedToF16(call->Result())) { - decorations.Add(call->Result()); - return true; - } - return false; + return DecorateIfConvertedToF16(call->Result()); } // Functions that write texel data can potentially have the texel value decorated as @@ -215,11 +212,7 @@ struct State { // the originating variable cannot be either. case BuiltinFn::kImageWrite: { auto* texel = call->Operand(2); - if (IsConvertedFromF16(texel)) { - decorations.Add(texel); - return true; - } - return false; + return DecorateIfConvertedFromF16(texel); } // Walk through OpSampledImage to check the sampling operations. @@ -239,12 +232,16 @@ struct State { } } - /// @returns true if @p value is converted to an f16 type before any use - bool IsConvertedToF16(core::ir::Value* value) { + /// Decorates @p value and its walked usages (lets, swizzles) with RelaxedPrecision if they are + /// eventually converted to an f16 type before any other use. + /// @returns true if @p value and its usages were decorated. + bool DecorateIfConvertedToF16(core::ir::Value* value) { // Walk uses of the value. Vector worklist{value}; + Vector to_decorate; while (!worklist.IsEmpty()) { auto* next = worklist.Pop(); + to_decorate.Push(next); for (auto use : next->UsagesUnsorted()) { auto* inst = use->instruction; if (inst->Is()) { @@ -252,8 +249,8 @@ struct State { if (!IsF16(inst->Result()->Type())) { return false; } - } else if (inst->Is()) { - // Walk through let instructions. + } else if (inst->IsAnyOf()) { + // Walk through let and swizzle instructions. worklist.Push(inst->Result()); } else { // Any other instruction halts the analysis. @@ -261,13 +258,21 @@ struct State { } } } + for (auto* v : to_decorate) { + decorations.Add(v); + } return true; } - /// @returns true if @p value was converted from an f16 type - bool IsConvertedFromF16(core::ir::Value* value) { + /// Decorates @p value and its source instructions (lets, swizzles) with RelaxedPrecision if it + /// was eventually converted from an f16 type. + /// @returns true if @p value and its source instructions were decorated. + bool DecorateIfConvertedFromF16(core::ir::Value* value) { // Walk backwards from the value. + Vector to_decorate; while (true) { + to_decorate.Push(value); + auto* result = value->As(); if (!result) { return false; @@ -276,11 +281,21 @@ struct State { auto* inst = result->Instruction(); if (inst->IsAnyOf()) { // Check if we are converting from F16. - return IsF16(inst->Operand(0)->Type()); + if (IsF16(inst->Operand(0)->Type())) { + for (auto* v : to_decorate) { + decorations.Add(v); + } + return true; + } + return false; } else if (auto* let = inst->As()) { // Walk through let instructions. value = let->Value(); continue; + } else if (auto* swizzle = inst->As()) { + // Walk through swizzle instructions. + value = swizzle->Object(); + continue; } else { // Any other instructions halts the analysis. return false; diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/common/binary_writer.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/common/binary_writer.cc index 6e9d535c7..d25f8c8c7 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/common/binary_writer.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/common/binary_writer.cc @@ -25,17 +25,13 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers -#endif - #include "src/tint/lang/spirv/writer/common/binary_writer.h" #include #include #include "src/tint/utils/memory/bitcast.h" +#include "src/utils/compiler.h" namespace tint::spirv::writer { namespace { @@ -85,7 +81,7 @@ void BinaryWriter::ProcessOp(const Operand& op) { if (auto* str = std::get_if(&op)) { auto idx = out_.size(); out_.resize(out_.size() + OperandLength(op), 0); - memcpy(&out_[idx], str->c_str(), str->size() + 1); + DAWN_UNSAFE_TODO(memcpy(&out_[idx], str->c_str(), str->size() + 1)); return; } } diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/common/option_helper.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/common/option_helper.cc index c4355e2fe..498abbc99 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/common/option_helper.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/common/option_helper.cc @@ -26,7 +26,9 @@ // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include +#include +#include "src/tint/api/common/bindings.h" #include "src/tint/lang/spirv/writer/common/option_helpers.h" #include "src/tint/utils/containers/hashmap.h" #include "src/tint/utils/diagnostic/diagnostic.h" @@ -106,6 +108,10 @@ Result ValidateBindingOptions(const Options& options) { diagnostics.AddNote(Source{}) << "when processing storage_texture"; return Failure{diagnostics.Str()}; } + if (!valid(options.bindings.texel_buffer)) { + diagnostics.AddNote(Source{}) << "when processing texel_buffer"; + return Failure{diagnostics.Str()}; + } if (!valid(options.bindings.sampler)) { diagnostics.AddNote(Source{}) << "when processing sampler"; return Failure{diagnostics.Str()}; @@ -117,21 +123,36 @@ Result ValidateBindingOptions(const Options& options) { for (const auto& it : options.bindings.external_texture) { const auto& src_binding = it.first; - const auto& plane0 = it.second.plane0; - const auto& plane1 = it.second.plane1; - const auto& metadata = it.second.metadata; + auto& data = it.second; + + BindingPoint src; + BindingPoint helper; + BindingPoint metadata; + if (std::holds_alternative(data)) { + ExternalMultiplanarTexture et = std::get(data); + src = et.plane0; + helper = et.plane1; + metadata = et.metadata; + } else if (std::holds_alternative(data)) { + ExternalYCBCRTexture ycb = std::get(data); + src = ycb.texture; + helper = ycb.sampler; + metadata = ycb.metadata; + } else { + TINT_UNREACHABLE(); + } // Validate with the actual source regardless of what the remapper will do - if (wgsl_seen(src_binding, plane0)) { + if (wgsl_seen(src_binding, src)) { diagnostics.AddNote(Source{}) << "when processing external_texture"; return Failure{diagnostics.Str()}; } - if (spirv_seen(plane0, src_binding)) { + if (spirv_seen(src, src_binding)) { diagnostics.AddNote(Source{}) << "when processing external_texture"; return Failure{diagnostics.Str()}; } - if (spirv_seen(plane1, src_binding)) { + if (spirv_seen(helper, src_binding)) { diagnostics.AddNote(Source{}) << "when processing external_texture"; return Failure{diagnostics.Str()}; } @@ -207,26 +228,48 @@ void PopulateRemapperAndMultiplanarOptions( create_remappings(options.bindings.storage); create_remappings(options.bindings.texture); create_remappings(options.bindings.storage_texture); + create_remappings(options.bindings.texel_buffer); create_remappings(options.bindings.sampler); create_remappings(options.bindings.input_attachment); // External textures are re-bound to their plane0 location for (const auto& it : options.bindings.external_texture) { const BindingPoint& src_binding_point = it.first; - const auto& plane0 = it.second.plane0; - const auto& plane1 = it.second.plane1; - const auto& metadata = it.second.metadata; + auto& data = it.second; - // Use the re-bound spir-v plane0 value for the lookup key. - multiplanar_map.emplace(plane0, - tint::transform::multiplanar::BindingPoints{plane1, metadata}); + BindingPoint dest_bp; + if (std::holds_alternative(data)) { + ExternalMultiplanarTexture et = std::get(data); + const auto& plane0 = et.plane0; + const auto& plane1 = et.plane1; + const auto& metadata = et.metadata; + + // Use the re-bound spir-v plane0 value for the lookup key. + multiplanar_map.emplace( + plane0, tint::transform::multiplanar::MultiplanarTexture{plane1, metadata}); + + dest_bp = plane0; + } else if (std::holds_alternative(data)) { + ExternalYCBCRTexture ycb = std::get(data); + const auto& texture = ycb.texture; + const auto& sampler = ycb.sampler; + const auto& metadata = ycb.metadata; + + // Use the re-bound spir-v texture value for the lookup key. + multiplanar_map.emplace(texture, + tint::transform::multiplanar::YCBCRTexture{sampler, metadata}); + + dest_bp = texture; + } else { + TINT_UNREACHABLE(); + } // Bindings which go to the same slot in SPIR-V do not need to be re-bound. - if (src_binding_point == plane0) { + if (src_binding_point == dest_bp) { continue; } - remapper_data.emplace(src_binding_point, plane0); + remapper_data.emplace(src_binding_point, dest_bp); } } diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/common/options.h b/3rdparty/dawn/src/tint/lang/spirv/writer/common/options.h index 1d6b96c98..848e264f8 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/common/options.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/common/options.h @@ -37,7 +37,7 @@ #include "src/tint/api/common/bindings.h" #include "src/tint/api/common/resource_table_config.h" #include "src/tint/api/common/substitute_overrides_config.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint::spirv::writer { @@ -54,6 +54,26 @@ enum class SpvVersion : uint32_t { kSpv15, // SPIR-V 1.5, for testing purposes only }; +/// @param out the stream to write to +/// @param version the SpvVersion +/// @returns @p out so calls can be chained +template + requires(traits::IsOStream) +auto& operator<<(STREAM& out, SpvVersion version) { + switch (version) { + case SpvVersion::kSpv13: + out << "1.3"; + break; + case SpvVersion::kSpv14: + out << "1.4"; + break; + case SpvVersion::kSpv15: + out << "1.5"; + break; + } + return out; +} + /// Configuration options used for generating SPIR-V. struct Options { struct RangeOffsets { @@ -87,41 +107,58 @@ struct Options { /// and `unpack4x8unorm` builtins bool polyfill_pack_unpack_4x8_norm = false; - /// Set to `true` to generate a polyfill clamp of `id` param of subgroupShuffle to within - /// the spec max subgroup size. - bool subgroup_shuffle_clamped = false; - /// Set to 'true' to force workaround for 'textureSampleCompare(Level)' for texture arrays /// of cube depth. bool texture_sample_compare_depth_cube_array = false; + /// Set to 'true' to force a polyfill for 'textureSampleCompare(Level)' for all 2D + /// textures (and arrays) using bilinear interpolation. + bool texture_sample_compare_2d_polyfill = false; + /// Set to `true` to generate polyfill for `subgroupBroadcast(f16)` bool polyfill_subgroup_broadcast_f16 = false; /// Set to `true` to always pass matrices to user functions by pointer instead of by value. bool pass_matrix_by_pointer = false; - /// Set to `true` to generate polyfill for f32 negation. - bool polyfill_unary_f32_negation = false; + /// Set to `true` to generate polyfill for f32 and f16 negation. + bool polyfill_float_negation = false; - /// Set to `true` to generate polyfill for f32 abs. - bool polyfill_f32_abs = false; + /// Set to `true` to generate polyfill for f32 and f16 abs. + bool polyfill_float_abs = false; + + /// Set to `true` to generate polyfill for length(scalar f32 and f16). + bool polyfill_length_scalar_float = false; + + /// Set to `true` to generate polyfill for distance(scalar f32 and f16). + bool polyfill_distance_scalar_float = false; /// Set to `true` to generate polyfill for f16 saturate. bool polyfill_saturate_as_min_max_f16 = false; + /// Set to `true` to treat the stride operand of cooperative matrix load and store + /// instructions as matrix elements instead of a source/dest pointee elements. + bool cooperative_matrix_stride_is_matrix_elements = false; + + /// Set to `true` to collapse redundant subgroup min and max operations + bool collapse_subgroup_min_max = false; + TINT_REFLECT(Workarounds, polyfill_case_switch, scalarize_max_min_clamp, dva_transform_handle, polyfill_pack_unpack_4x8_norm, - subgroup_shuffle_clamped, texture_sample_compare_depth_cube_array, + texture_sample_compare_2d_polyfill, polyfill_subgroup_broadcast_f16, pass_matrix_by_pointer, - polyfill_unary_f32_negation, - polyfill_f32_abs, - polyfill_saturate_as_min_max_f16); + polyfill_float_negation, + polyfill_float_abs, + polyfill_length_scalar_float, + polyfill_distance_scalar_float, + polyfill_saturate_as_min_max_f16, + cooperative_matrix_stride_is_matrix_elements, + collapse_subgroup_min_max); }; /// Any options which are controlled by the presence/absence of a vulkan extension. @@ -212,8 +249,12 @@ struct Options { /// from all vertex shaders in the module. bool emit_vertex_point_size = true; - /// Set to `true` to apply builtin 'position' pixel center emulation. - bool polyfill_pixel_center = false; + /// If the optional is set, then we apply the builtin 'position' pixel center emulation with a + /// location provided by the optional. + std::optional polyfill_pixel_center = std::nullopt; + + /// Set to `true` if framebuffer fetch should be multisampled + bool multisampled_framebuffer_fetch = false; /// Any workarounds to enable/disable. Workarounds workarounds{}; @@ -247,6 +288,7 @@ struct Options { disable_integer_range_analysis, emit_vertex_point_size, polyfill_pixel_center, + multisampled_framebuffer_fetch, workarounds, extensions, depth_range_offsets, diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.cc index 7d41f94f3..0ed78ea19 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.cc @@ -37,7 +37,6 @@ #include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/fluent_types.h" #include "src/tint/lang/core/ir/access.h" -#include "src/tint/lang/core/ir/bitcast.h" #include "src/tint/lang/core/ir/block.h" #include "src/tint/lang/core/ir/block_param.h" #include "src/tint/lang/core/ir/break_if.h" @@ -91,8 +90,8 @@ #include "src/tint/lang/spirv/ir/binary.h" #include "src/tint/lang/spirv/ir/builtin_call.h" #include "src/tint/lang/spirv/ir/copy_logical.h" -#include "src/tint/lang/spirv/ir/literal_operand.h" #include "src/tint/lang/spirv/type/explicit_layout_array.h" +#include "src/tint/lang/spirv/type/literal.h" #include "src/tint/lang/spirv/type/sampled_image.h" #include "src/tint/lang/spirv/writer/analysis/relaxed_precision_decorations.h" #include "src/tint/lang/spirv/writer/common/binary_writer.h" @@ -151,9 +150,6 @@ const core::type::Type* DedupType(const core::type::Type* ty, core::type::Manage if (s->IsComparison()) { return types.Get(core::type::SamplerKind::kSampler); } - if (s->Filtering() != core::SamplerFiltering::kUndefined) { - return types.Get(core::type::SamplerKind::kSampler); - } return s; }, @@ -185,6 +181,12 @@ const core::type::Type* DedupType(const core::type::Type* ty, core::type::Manage [&](Default) { return ty; }); } +// The list of properties that are not supported. +const core::ir::Properties kUnsupportedProperties{ + core::ir::Property::kAllowMultipleEntryPoints, + core::ir::Property::kAllowOverrides, +}; + /// PIMPL class for SPIR-V writer class Printer { public: @@ -298,7 +300,8 @@ class Printer { /// Builds the SPIR-V from the IR Result Generate() { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir_, kPrinterCapabilities, "spirv.Printer")); + AssertValid(ir_, kPrinterCapabilities, "before spirv.Printer"); + AssertNoUnsupportedProperties(ir_, kUnsupportedProperties); module_.PushCapability(SpvCapabilityShader); @@ -324,11 +327,16 @@ class Printer { // Emit RelaxedPrecision decorations. auto relaxed_precision_decorations = analysis::GetRelaxedPrecisionDecorations(ir_); + Hashset decorated_ids; for (const auto& deco : relaxed_precision_decorations) { - module_.PushAnnot(spv::Op::OpDecorate, { - Value(deco), - U32Operand(SpvDecorationRelaxedPrecision), - }); + uint32_t id = Value(deco); + if (decorated_ids.Add(id)) { + module_.PushAnnot(spv::Op::OpDecorate, + { + id, + U32Operand(SpvDecorationRelaxedPrecision), + }); + } } return Success; @@ -413,8 +421,8 @@ class Printer { /// @returns the result ID of the constant uint32_t Constant(const core::ir::Constant* constant) { // If it is a literal operand, just return the value. - if (auto* literal = constant->As()) { - return literal->Value()->ValueAs(); + if (constant->Type()->Is()) { + return constant->Value()->ValueAs(); } auto id = Constant(constant->Value()); @@ -446,19 +454,19 @@ class Printer { {Type(ty), id}); }, [&](const core::type::I32*) { - module_.PushType(spv::Op::OpConstant, {Type(ty), id, constant->ValueAs()}); + module_.PushType(spv::Op::OpConstant, + {Type(ty), id, U32Operand(constant->ValueAs())}); }, [&](const core::type::U32*) { - module_.PushType(spv::Op::OpConstant, - {Type(ty), id, U32Operand(constant->ValueAs())}); - }, - [&](const core::type::I8*) { module_.PushType(spv::Op::OpConstant, {Type(ty), id, constant->ValueAs()}); }, - [&](const core::type::U8*) { + [&](const core::type::I8*) { module_.PushType(spv::Op::OpConstant, {Type(ty), id, U32Operand(constant->ValueAs())}); }, + [&](const core::type::U8*) { + module_.PushType(spv::Op::OpConstant, {Type(ty), id, constant->ValueAs()}); + }, [&](const core::type::F32*) { module_.PushType(spv::Op::OpConstant, {Type(ty), id, constant->ValueAs()}); }, @@ -998,7 +1006,6 @@ class Printer { Switch( inst, // [&](core::ir::Access* a) { EmitAccess(a); }, // - [&](core::ir::Bitcast* b) { EmitBitcast(b); }, // [&](core::ir::CoreBinary* b) { EmitBinary(b); }, // [&](spirv::ir::Binary* b) { EmitSpirvBinary(b); }, // [&](core::ir::CoreBuiltinCall* b) { EmitCoreBuiltinCall(b); }, // @@ -1048,8 +1055,8 @@ class Printer { tint::Switch( // t, // [&](core::ir::Return*) { - if (!t->Args().IsEmpty()) { - TINT_IR_ASSERT(ir_, t->Args().Length() == 1u); + if (!t->Args().empty()) { + TINT_IR_ASSERT(ir_, t->Args().size() == 1u); OperandList operands; operands.push_back(Value(t->Args()[0])); current_function_.PushInst(spv::Op::OpReturnValue, operands); @@ -1410,14 +1417,14 @@ class Printer { /// Emit a bitcast instruction. /// @param bitcast the bitcast instruction to emit - void EmitBitcast(core::ir::Bitcast* bitcast) { + void EmitBitcast(core::ir::CoreBuiltinCall* bitcast) { auto* ty = bitcast->Result()->Type(); - if (ty == bitcast->Val()->Type()) { - values_.Add(bitcast->Result(), Value(bitcast->Val())); + if (ty == bitcast->Args()[0]->Type()) { + values_.Add(bitcast->Result(), Value(bitcast->Args()[0])); return; } current_function_.PushInst(spv::Op::OpBitcast, - {Type(ty), Value(bitcast), Value(bitcast->Val())}); + {Type(ty), Value(bitcast), Value(bitcast->Args()[0])}); } /// Emit a builtin function call instruction. @@ -1554,6 +1561,13 @@ class Printer { case spirv::BuiltinFn::kImageWrite: op = spv::Op::OpImageWrite; break; + case spirv::BuiltinFn::kInterpolateAtOffset: + // InterpolateAtOffset requires the InterpolationFunction capability. + // In Dawn this is only used for the pixel center polyfill which is only + // enabled if SampleRateShading is available. + module_.PushCapability(SpvCapabilityInterpolationFunction); + ext_inst(GLSLstd450InterpolateAtOffset); + break; case spirv::BuiltinFn::kMatrixTimesMatrix: op = spv::Op::OpMatrixTimesMatrix; break; @@ -1785,6 +1799,9 @@ class Printer { case BuiltinFn::kSConvert: op = spv::Op::OpSConvert; break; + case BuiltinFn::kAddCarry: + op = spv::Op::OpIAddCarry; + break; case spirv::BuiltinFn::kNone: TINT_IR_ICE(ir_) << "undefined spirv ir function"; } @@ -1833,6 +1850,11 @@ class Printer { return; } + if (builtin->Func() == core::BuiltinFn::kBitcast) { + EmitBitcast(builtin); + return; + } + auto id = Value(builtin); spv::Op op = spv::Op::Max; @@ -2338,7 +2360,7 @@ class Printer { // If there is just a single argument with the same type as the result, this is an identity // constructor and we can just pass through the ID of the argument. - if (construct->Args().Length() == 1 && result_ty == construct->Args()[0]->Type()) { + if (construct->Args().size() == 1 && result_ty == construct->Args()[0]->Type()) { values_.Add(construct->Result(), Value(construct->Args()[0])); return; } @@ -2708,12 +2730,13 @@ class Printer { auto* ptr = var->Result()->Type()->As(); if (ptr->AddressSpace() == core::AddressSpace::kWorkgroup) { auto* ty = ptr->StoreType(); - uint32_t align = ty->Align(); - uint32_t size = ty->Size(); + uint64_t align = ty->Align(); + uint64_t size = ty->Size(); // This essentially matches std430 layout rules from GLSL, which are in // turn specified as an upper bound for Vulkan layout sizing. - output_.workgroup_info.storage_size += tint::RoundUp(16u, tint::RoundUp(align, size)); + output_.workgroup_info.storage_size += + tint::RoundUp(static_cast(16u), tint::RoundUp(align, size)); } EmitVar(var); } diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.h b/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.h index 0922e3e22..437a501ca 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/printer/printer.h @@ -42,10 +42,6 @@ namespace tint::spirv::writer { // The capabilities that might be needed due to raising. const core::ir::Capabilities kPrinterCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, core::ir::Capability::kLoosenValidationForShaderIO, }; diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc index 5ab1b7c5a..83811e1b3 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.cc @@ -28,6 +28,7 @@ #include "src/tint/lang/spirv/writer/raise/builtin_polyfill.h" #include +#include #include "spirv/unified1/spirv.h" #include "src/tint/lang/core/enums.h" @@ -52,7 +53,7 @@ #include "src/tint/lang/core/type/u8.h" #include "src/tint/lang/spirv/ir/binary.h" #include "src/tint/lang/spirv/ir/builtin_call.h" -#include "src/tint/lang/spirv/ir/literal_operand.h" +#include "src/tint/lang/spirv/type/literal.h" #include "src/tint/lang/spirv/type/sampled_image.h" #include "src/tint/utils/ice/ice.h" #include "src/tint/utils/internal_limits.h" @@ -183,10 +184,12 @@ struct State { /// The type manager. core::type::Manager& ty{ir.Types()}; + /// Module-scoped variable for subgroup size mask. + core::ir::Var* subgroup_size_mask_ = nullptr; + /// Process the module. void Process() { // Find the builtins that need replacing. - Vector worklist; Vector subgroup_matrix_constructors; // Replace types for function parameters if necessary @@ -198,6 +201,9 @@ struct State { } } + std::vector> worklist; + worklist.reserve(128); + for (auto* inst : ir.Instructions()) { // Replace types for instruction results if necessary for (auto* result : inst->Results()) { @@ -209,11 +215,11 @@ struct State { if (auto* builtin = inst->As()) { switch (builtin->Func()) { case core::BuiltinFn::kArrayLength: + worklist.push_back([this, builtin] { ArrayLength(builtin); }); + break; case core::BuiltinFn::kAtomicAdd: case core::BuiltinFn::kAtomicAnd: case core::BuiltinFn::kAtomicCompareExchangeWeak: - case core::BuiltinFn::kAtomicStoreMax: - case core::BuiltinFn::kAtomicStoreMin: case core::BuiltinFn::kAtomicExchange: case core::BuiltinFn::kAtomicLoad: case core::BuiltinFn::kAtomicMax: @@ -222,45 +228,102 @@ struct State { case core::BuiltinFn::kAtomicStore: case core::BuiltinFn::kAtomicSub: case core::BuiltinFn::kAtomicXor: + case core::BuiltinFn::kAtomicStoreMax: + case core::BuiltinFn::kAtomicStoreMin: + worklist.push_back([this, builtin] { Atomic(builtin); }); + break; case core::BuiltinFn::kDot: + worklist.push_back([this, builtin] { Dot(builtin); }); + break; case core::BuiltinFn::kDot4I8Packed: case core::BuiltinFn::kDot4U8Packed: + worklist.push_back([this, builtin] { DotPacked4x8(builtin); }); + break; case core::BuiltinFn::kQuadBroadcast: + worklist.push_back([this, builtin] { QuadBroadcast(builtin); }); + break; case core::BuiltinFn::kSelect: + worklist.push_back([this, builtin] { Select(builtin); }); + break; case core::BuiltinFn::kSubgroupBroadcast: + worklist.push_back([this, builtin] { SubgroupBroadcast(builtin); }); + break; case core::BuiltinFn::kSubgroupShuffle: case core::BuiltinFn::kSubgroupShuffleDown: case core::BuiltinFn::kSubgroupShuffleUp: - case core::BuiltinFn::kSubgroupShuffleXor: + case core::BuiltinFn::kSubgroupShuffleXor: { + worklist.push_back([this, builtin] { SubgroupShuffle(builtin); }); + break; + } case core::BuiltinFn::kTextureDimensions: + worklist.push_back([this, builtin] { TextureDimensions(builtin); }); + break; case core::BuiltinFn::kTextureGather: case core::BuiltinFn::kTextureGatherCompare: + worklist.push_back([this, builtin] { TextureGather(builtin); }); + break; case core::BuiltinFn::kTextureLoad: + worklist.push_back([this, builtin] { TextureLoad(builtin); }); + break; case core::BuiltinFn::kTextureNumLayers: + worklist.push_back([this, builtin] { TextureNumLayers(builtin); }); + break; case core::BuiltinFn::kTextureNumLevels: + worklist.push_back([this, builtin] { TextureNumLevels(builtin); }); + break; case core::BuiltinFn::kTextureNumSamples: + worklist.push_back([this, builtin] { TextureNumSamples(builtin); }); + break; case core::BuiltinFn::kTextureSample: case core::BuiltinFn::kTextureSampleBias: case core::BuiltinFn::kTextureSampleCompare: case core::BuiltinFn::kTextureSampleCompareLevel: case core::BuiltinFn::kTextureSampleGrad: case core::BuiltinFn::kTextureSampleLevel: + worklist.push_back([this, builtin] { TextureSample(builtin); }); + break; case core::BuiltinFn::kTextureStore: - case core::BuiltinFn::kInputAttachmentLoad: - case core::BuiltinFn::kSubgroupMatrixLoad: - case core::BuiltinFn::kSubgroupMatrixStore: - case core::BuiltinFn::kSubgroupMatrixMultiply: - case core::BuiltinFn::kSubgroupMatrixMultiplyAccumulate: - case core::BuiltinFn::kSubgroupMatrixScalarAdd: - case core::BuiltinFn::kSubgroupMatrixScalarSubtract: - case core::BuiltinFn::kSubgroupMatrixScalarMultiply: - worklist.Push(builtin); + worklist.push_back([this, builtin] { TextureStore(builtin); }); break; case core::BuiltinFn::kQuantizeToF16: if (builtin->Result()->Type()->Is()) { - worklist.Push(builtin); + worklist.push_back([this, builtin] { QuantizeToF16Vec(builtin); }); } break; + case core::BuiltinFn::kInputAttachmentLoad: + worklist.push_back([this, builtin] { InputAttachmentLoad(builtin); }); + break; + case core::BuiltinFn::kSubgroupMatrixLoad: + worklist.push_back([this, builtin] { SubgroupMatrixLoad(builtin); }); + break; + case core::BuiltinFn::kSubgroupMatrixStore: + worklist.push_back([this, builtin] { SubgroupMatrixStore(builtin); }); + break; + case core::BuiltinFn::kSubgroupMatrixMultiply: + worklist.push_back([this, builtin] { SubgroupMatrixMultiply(builtin); }); + break; + case core::BuiltinFn::kSubgroupMatrixMultiplyAccumulate: + worklist.push_back( + [this, builtin] { SubgroupMatrixMultiplyAccumulate(builtin); }); + break; + case core::BuiltinFn::kSubgroupMatrixScalarAdd: + worklist.push_back([this, builtin] { + SubgroupMatrixScalar(builtin, core::BinaryOp::kAdd); + }); + break; + case core::BuiltinFn::kSubgroupMatrixScalarSubtract: + worklist.push_back([this, builtin] { + SubgroupMatrixScalar(builtin, core::BinaryOp::kSubtract); + }); + break; + case core::BuiltinFn::kSubgroupMatrixScalarMultiply: + worklist.push_back([this, builtin] { + SubgroupMatrixScalar(builtin, core::BinaryOp::kMultiply); + }); + break; + case core::BuiltinFn::kAddSat: + worklist.push_back([this, builtin] { AddSat(builtin); }); + break; default: break; } @@ -268,7 +331,7 @@ struct State { if (auto* construct = inst->As()) { if (auto* sm = construct->Result()->Type()->As()) { if (sm->Type()->IsAnyOf() && - construct->Args().Length() > 0) { + construct->Args().size() > 0) { subgroup_matrix_constructors.Push(construct); } } @@ -276,139 +339,84 @@ struct State { } // Replace the builtins that we found. - for (auto* builtin : worklist) { - switch (builtin->Func()) { - case core::BuiltinFn::kArrayLength: - ArrayLength(builtin); - break; - case core::BuiltinFn::kAtomicAdd: - case core::BuiltinFn::kAtomicAnd: - case core::BuiltinFn::kAtomicCompareExchangeWeak: - case core::BuiltinFn::kAtomicExchange: - case core::BuiltinFn::kAtomicLoad: - case core::BuiltinFn::kAtomicMax: - case core::BuiltinFn::kAtomicMin: - case core::BuiltinFn::kAtomicOr: - case core::BuiltinFn::kAtomicStore: - case core::BuiltinFn::kAtomicSub: - case core::BuiltinFn::kAtomicXor: - case core::BuiltinFn::kAtomicStoreMax: - case core::BuiltinFn::kAtomicStoreMin: - Atomic(builtin); - break; - case core::BuiltinFn::kDot: - Dot(builtin); - break; - case core::BuiltinFn::kDot4I8Packed: - case core::BuiltinFn::kDot4U8Packed: - DotPacked4x8(builtin); - break; - case core::BuiltinFn::kQuadBroadcast: - QuadBroadcast(builtin); - break; - case core::BuiltinFn::kSelect: - Select(builtin); - break; - case core::BuiltinFn::kSubgroupBroadcast: - SubgroupBroadcast(builtin); - break; - case core::BuiltinFn::kSubgroupShuffle: - case core::BuiltinFn::kSubgroupShuffleDown: - case core::BuiltinFn::kSubgroupShuffleUp: - case core::BuiltinFn::kSubgroupShuffleXor: - SubgroupShuffle(builtin, config.subgroup_shuffle_clamped); - break; - case core::BuiltinFn::kTextureDimensions: - TextureDimensions(builtin); - break; - case core::BuiltinFn::kTextureGather: - case core::BuiltinFn::kTextureGatherCompare: - TextureGather(builtin); - break; - case core::BuiltinFn::kTextureLoad: - TextureLoad(builtin); - break; - case core::BuiltinFn::kTextureNumLayers: - TextureNumLayers(builtin); - break; - case core::BuiltinFn::kTextureNumLevels: - TextureNumLevels(builtin); - break; - case core::BuiltinFn::kTextureNumSamples: - TextureNumSamples(builtin); - break; - case core::BuiltinFn::kTextureSample: - case core::BuiltinFn::kTextureSampleBias: - case core::BuiltinFn::kTextureSampleCompare: - case core::BuiltinFn::kTextureSampleCompareLevel: - case core::BuiltinFn::kTextureSampleGrad: - case core::BuiltinFn::kTextureSampleLevel: - TextureSample(builtin); - break; - case core::BuiltinFn::kTextureStore: - TextureStore(builtin); - break; - case core::BuiltinFn::kQuantizeToF16: - QuantizeToF16Vec(builtin); - break; - case core::BuiltinFn::kInputAttachmentLoad: - InputAttachmentLoad(builtin); - break; - case core::BuiltinFn::kSubgroupMatrixLoad: - SubgroupMatrixLoad(builtin); - break; - case core::BuiltinFn::kSubgroupMatrixStore: - SubgroupMatrixStore(builtin); - break; - case core::BuiltinFn::kSubgroupMatrixMultiply: - SubgroupMatrixMultiply(builtin); - break; - case core::BuiltinFn::kSubgroupMatrixMultiplyAccumulate: - SubgroupMatrixMultiplyAccumulate(builtin); - break; - case core::BuiltinFn::kSubgroupMatrixScalarAdd: - SubgroupMatrixScalar(builtin, core::BinaryOp::kAdd); - break; - case core::BuiltinFn::kSubgroupMatrixScalarSubtract: - SubgroupMatrixScalar(builtin, core::BinaryOp::kSubtract); - break; - case core::BuiltinFn::kSubgroupMatrixScalarMultiply: - SubgroupMatrixScalar(builtin, core::BinaryOp::kMultiply); - break; - default: - break; - } + for (auto& cb : worklist) { + cb(); } // Replace non-zero subgroup matrix constructors that use 8-bit component types. // SPIR-V requires that the value passed to OpCompositeConstruct is an 8-bit value. for (auto* construct : subgroup_matrix_constructors) { auto* sm_ty = construct->Result()->Type()->As(); - TINT_IR_ASSERT(ir, construct->Args().Length() == 1u); + TINT_IR_ASSERT(ir, construct->Args().size() == 1u); TINT_IR_ASSERT(ir, sm_ty); auto* value = construct->Args()[0]; b.InsertBefore(construct, [&] { if (sm_ty->Type()->Is()) { value = b.CallExplicit( - ty.i8(), spirv::BuiltinFn::kSConvert, Vector{ty.i8()}, + ty.i8(), spirv::BuiltinFn::kSConvert, + Vector{ty.i8()}, b.Clamp(value, -128_i, 127_i)) ->Result(); } else if (sm_ty->Type()->Is()) { value = b.CallExplicit( - ty.u8(), spirv::BuiltinFn::kUConvert, Vector{ty.u8()}, + ty.u8(), spirv::BuiltinFn::kUConvert, + Vector{ty.u8()}, b.Clamp(value, 0_u, 255_u)) ->Result(); } }); construct->SetArg(0, value); } + + if (subgroup_size_mask_) { + for (auto func : ir.functions) { + if (func->IsEntryPoint()) { + SetSubgroupSizeMaskForEntryPoint(func); + } + } + } + } + + /// Set the subgroup_size_mask variable from an entry point. + void SetSubgroupSizeMaskForEntryPoint(core::ir::Function* ep) { + b.InsertBefore(ep->Block()->Front(), [&] { + core::ir::Value* subgroup_size = nullptr; + for (auto* param : ep->Params()) { + if (param->Attributes().builtin == core::BuiltinValue::kSubgroupSize) { + subgroup_size = param; + break; + } + if (auto* str = param->Type()->As()) { + for (auto* member : str->Members()) { + if (member->Attributes().builtin == core::BuiltinValue::kSubgroupSize) { + subgroup_size = + b.Access(ty.u32(), param, u32(member->Index()))->Result(); + break; + } + } + if (subgroup_size) { + break; + } + } + } + if (!subgroup_size) { + auto* param = b.FunctionParam("tint_subgroup_size", ty.u32()); + param->SetBuiltin(core::BuiltinValue::kSubgroupSize); + ep->AppendParam(param); + subgroup_size = param; + } + + auto* mask = b.Subtract(subgroup_size, 1_u); + b.Store(subgroup_size_mask_, mask); + }); } /// Create a literal operand. /// @param value the literal value /// @returns the literal operand - spirv::ir::LiteralOperand* Literal(u32 value) { - return ir.CreateValue(b.ConstantValue(value)); + core::ir::Value* Literal(u32 value) { + return b.Constant( + ir.constant_values.Get>(ty.Get(), value)); } /// Handle an `arrayLength()` builtin. @@ -423,7 +431,7 @@ struct State { auto* access = ptr->Instruction()->As(); TINT_IR_ASSERT(ir, access); - TINT_IR_ASSERT(ir, access->Indices().Length() == 1u); + TINT_IR_ASSERT(ir, access->Indices().size() == 1u); TINT_IR_ASSERT(ir, access->Object()->Type()->UnwrapPtr()->Is()); auto* const_idx = access->Indices()[0]->As(); @@ -743,7 +751,7 @@ struct State { // Helper to get the next argument from the call, or nullptr if there are no more arguments. uint32_t arg_idx = 0; auto next_arg = [&]() { - return arg_idx < builtin->Args().Length() ? builtin->Args()[arg_idx++] : nullptr; + return arg_idx < builtin->Args().size() ? builtin->Args()[arg_idx++] : nullptr; }; auto* texture = next_arg(); @@ -759,18 +767,24 @@ struct State { (builtin->Func() == core::BuiltinFn::kTextureSampleCompare || builtin->Func() == core::BuiltinFn::kTextureSampleCompareLevel); + // This includes both 2d and 2d array. + const bool is_depth_2d = (texture_ty->GetDim() == type::Dim::kD2) && + (texture_ty->GetDepth() == type::Depth::kDepth); + + const bool polyfill_depth_2d = + config.texture_sample_compare_2d_polyfill && is_depth_2d && + (builtin->Func() == core::BuiltinFn::kTextureSampleCompare || + builtin->Func() == core::BuiltinFn::kTextureSampleCompareLevel); + // Use OpSampledImage to create an OpTypeSampledImage object. auto* sampled_image = b.CallExplicit( ty.Get(texture_ty), spirv::BuiltinFn::kOpSampledImage, - Vector{texture_ty}, Vector{texture, sampler}); + Vector{texture_ty}, Vector{texture, sampler}); sampled_image->InsertBefore(builtin); // Append the array index to the coordinates if provided. auto* array_idx = texture_ty->GetArrayed() == type::Arrayed::kArrayed ? next_arg() : nullptr; - if (array_idx) { - coords = AppendArrayIndex(coords, array_idx, builtin); - } // Determine which SPIR-V function to use and which optional image operands are needed. enum spirv::BuiltinFn function = BuiltinFn::kNone; @@ -787,18 +801,18 @@ struct State { operands.offset = next_arg(); break; case core::BuiltinFn::kTextureSampleCompare: - function = polyfill_depth_cube_array + function = (polyfill_depth_cube_array || polyfill_depth_2d) ? spirv::BuiltinFn::kImageDrefGather : spirv::BuiltinFn::kImageSampleDrefImplicitLod; depth = next_arg(); operands.offset = next_arg(); break; case core::BuiltinFn::kTextureSampleCompareLevel: - function = polyfill_depth_cube_array + function = (polyfill_depth_cube_array || polyfill_depth_2d) ? spirv::BuiltinFn::kImageDrefGather : spirv::BuiltinFn::kImageSampleDrefExplicitLod; depth = next_arg(); - if (!polyfill_depth_cube_array) { + if (!polyfill_depth_cube_array && !polyfill_depth_2d) { operands.lod = b.Constant(0_f); } operands.offset = next_arg(); @@ -818,6 +832,46 @@ struct State { TINT_IR_UNREACHABLE(ir) << "unhandled texture sample builtin"; } + core::ir::Value* fract_bilinear = nullptr; + if (polyfill_depth_2d) { + b.InsertBefore(builtin, [&] { + // Get texture dimensions. The return type depends on if it was an array texture. + auto* dim = b.CallExplicit( + array_idx ? ty.vec3u() : ty.vec2u(), spirv::BuiltinFn::kImageQuerySizeLod, + Vector{ty.u32()}, texture, b.Constant(0_i)); + + auto* dim2u = b.Swizzle(ty.vec2u(), dim, {0, 1}); + auto* fdim = b.Convert(ty.vec2f(), dim2u); + + // Calculate texel position: coords * dim - 0.5 + auto* texelPos = + b.Subtract(b.Multiply(coords, fdim), b.Splat(ty.vec2f(), b.Constant(0.5_f))); + + if (operands.offset) { + texelPos = b.Add(texelPos, b.Convert(ty.vec2f(), operands.offset)); + // We've baked the offset into the coordinates, so clear it from the image + // operands. + operands.offset = nullptr; + } + + // Snap to texel as we will be doing the bilinear filtering manually. + auto* i_j = b.Call(ty.vec2f(), core::BuiltinFn::kFloor, texelPos); + + // fraction = texelPos - i_j + fract_bilinear = b.Subtract(texelPos, i_j)->Result(); + + // gatherUV = (i_j + 0.5) / dim + auto* gatherUV = b.Divide(b.Add(i_j, b.Splat(ty.vec2f(), b.Constant(0.5_f))), fdim); + + // Update coords for the gather call. + coords = gatherUV->Result(); + }); + } + + if (array_idx) { + coords = AppendArrayIndex(coords, array_idx, builtin); + } + // Start building the argument list for the function. // The first two operands are always the sampled image and then the coordinates, followed by // the depth reference if used. @@ -833,7 +887,7 @@ struct State { // Call the function. // If this is a depth comparison, the result is always f32, otherwise vec4f. - auto* result_ty = (depth && !polyfill_depth_cube_array) + auto* result_ty = (depth && !polyfill_depth_cube_array && !polyfill_depth_2d) ? static_cast(ty.f32()) : ty.vec4f(); @@ -849,26 +903,50 @@ struct State { } if (polyfill_depth_cube_array) { - core::ir::Instruction* close_to_pcf_result = nullptr; b.InsertAfter(result, [&] { // This is an imperfect polyfill for builtin intrinsic to do PCF style shadows. // See: crbug.com/467015399 - // To do a complete polyfill we would have to properly do bilinear interpolation of - // the TextureGatherCompare result which we do not do as there is no trivial way to - // do it for a cubemap. + // To do a complete polyfill we would have to properly do bilinear interpolation + // of the TextureGatherCompare result which we do not do as there is no trivial + // way to do it for a cubemap. - // We do a textureGatherCompare and then dot with a vec4f(0.25) to get the average - // result. This will give PCF-like shadows but they will not be as smooth as the - // result from the original TextureSampleCompare. We also only sample mip0 which is - // identical to TextureSampleCompareLevel but not TextureSampleCompare. - close_to_pcf_result = - b.Call(ty.f32(), spirv::BuiltinFn::kDot, result, - b.Splat(ty.vec4f(), b.Constant(0.25_f))); + // We do a textureGatherCompare and then dot with a vec4f(0.25) to get the + // average result. This will give PCF-like shadows but they will not be as + // smooth as the result from the original TextureSampleCompare. We also only + // sample mip0 which is identical to TextureSampleCompareLevel but not + // TextureSampleCompare. + result = b.Call(ty.f32(), spirv::BuiltinFn::kDot, result, + b.Splat(ty.vec4f(), b.Constant(0.25_f))); }); + } - close_to_pcf_result->SetResult(builtin->DetachResult()); - builtin->Destroy(); - return; + if (polyfill_depth_2d) { + b.InsertAfter(result, [&] { + // Bilinear interpolation for 2D sampleCompare (2D polyfill). + // result from OpImageDrefGather (textureGatherCompare) is vec4f: + // [0]: (i, j+1) + // [1]: (i+1, j+1) + // [2]: (i+1, j) + // [3]: (i, j) + auto* x = b.Access(ty.f32(), result, 0_u); + auto* y = b.Access(ty.f32(), result, 1_u); + auto* z = b.Access(ty.f32(), result, 2_u); + auto* w = b.Access(ty.f32(), result, 3_u); + + auto* fx = b.Access(ty.f32(), fract_bilinear, 0_u); + auto* fy = b.Access(ty.f32(), fract_bilinear, 1_u); + + // top = mix(result.w, result.z, fract_bilinear.x) + // where result.w == (i, j) + // result.z == (i+1, j) + // fract_bilinear.x) + auto* top = b.Call(ty.f32(), core::BuiltinFn::kMix, w, z, fx); + // bottom = mix(result.x, result.y, fract_bilinear.x) -> mix((i, j+1), (i+1, + // j+1), fract_bilinear.x) + auto* bottom = b.Call(ty.f32(), core::BuiltinFn::kMix, x, y, fx); + // Percentage-closer filtering = mix(top, bottom, fract_bilinear.y) + result = b.Call(ty.f32(), core::BuiltinFn::kMix, top, bottom, fy); + }); } result->SetResult(builtin->DetachResult()); @@ -881,7 +959,7 @@ struct State { // Helper to get the next argument from the call, or nullptr if there are no more arguments. uint32_t arg_idx = 0; auto next_arg = [&]() { - return arg_idx < builtin->Args().Length() ? builtin->Args()[arg_idx++] : nullptr; + return arg_idx < builtin->Args().size() ? builtin->Args()[arg_idx++] : nullptr; }; auto* component = next_arg(); @@ -899,7 +977,7 @@ struct State { // Use OpSampledImage to create an OpTypeSampledImage object. auto* sampled_image = b.CallExplicit( ty.Get(texture_ty), spirv::BuiltinFn::kOpSampledImage, - Vector{texture_ty}, Vector{texture, sampler}); + Vector{texture_ty}, Vector{texture, sampler}); sampled_image->InsertBefore(builtin); // Append the array index to the coordinates if provided. @@ -955,7 +1033,7 @@ struct State { // Helper to get the next argument from the call, or nullptr if there are no more arguments. uint32_t arg_idx = 0; auto next_arg = [&]() { - return arg_idx < builtin->Args().Length() ? builtin->Args()[arg_idx++] : nullptr; + return arg_idx < builtin->Args().size() ? builtin->Args()[arg_idx++] : nullptr; }; auto* texture = next_arg(); @@ -1014,7 +1092,7 @@ struct State { // Helper to get the next argument from the call, or nullptr if there are no more arguments. uint32_t arg_idx = 0; auto next_arg = [&]() { - return arg_idx < builtin->Args().Length() ? builtin->Args()[arg_idx++] : nullptr; + return arg_idx < builtin->Args().size() ? builtin->Args()[arg_idx++] : nullptr; }; auto* texture = next_arg(); @@ -1053,7 +1131,7 @@ struct State { // Helper to get the next argument from the call, or nullptr if there are no more arguments. uint32_t arg_idx = 0; auto next_arg = [&]() { - return arg_idx < builtin->Args().Length() ? builtin->Args()[arg_idx++] : nullptr; + return arg_idx < builtin->Args().size() ? builtin->Args()[arg_idx++] : nullptr; }; auto* texture = next_arg(); @@ -1087,7 +1165,8 @@ struct State { // Call the function. core::ir::Instruction* result = b.CallExplicit( - result_ty, function, Vector{ty.u32()}, std::move(function_args)); + result_ty, function, Vector{ty.u32()}, + std::move(function_args)); result->InsertBefore(builtin); // Swizzle the first two components from the result for arrayed textures. @@ -1108,9 +1187,9 @@ struct State { b.InsertBefore(builtin, [&] { // Call the function. auto* res_ty = builtin->Result()->Type(); - b.CallExplicitWithResult(builtin->DetachResult(), - spirv::BuiltinFn::kImageQueryLevels, - Vector{res_ty}, Vector{args[0]}); + b.CallExplicitWithResult( + builtin->DetachResult(), spirv::BuiltinFn::kImageQueryLevels, + Vector{res_ty}, Vector{args[0]}); }); builtin->Destroy(); } @@ -1123,9 +1202,9 @@ struct State { b.InsertBefore(builtin, [&] { // Call the function. auto* res_ty = builtin->Result()->Type(); - b.CallExplicitWithResult(builtin->DetachResult(), - spirv::BuiltinFn::kImageQuerySamples, - Vector{res_ty}, Vector{args[0]}); + b.CallExplicitWithResult( + builtin->DetachResult(), spirv::BuiltinFn::kImageQuerySamples, + Vector{res_ty}, Vector{args[0]}); }); builtin->Destroy(); } @@ -1151,7 +1230,8 @@ struct State { // Call the function. auto* texture_call = b.CallExplicit( - ty.vec3u(), function, Vector{ty.u32()}, std::move(function_args)); + ty.vec3u(), function, Vector{ty.u32()}, + std::move(function_args)); texture_call->InsertBefore(builtin); // Extract the third component to get the number of array layers. @@ -1185,7 +1265,7 @@ struct State { /// Handle an inputAttachmentLoad() builtin. /// @param builtin the builtin call instruction void InputAttachmentLoad(core::ir::CoreBuiltinCall* builtin) { - TINT_IR_ASSERT(ir, builtin->Args().Length() == 1); + TINT_IR_ASSERT(ir, builtin->Args().size() == 1); auto* texture = builtin->Args()[0]; // coords for input_attachment are always (0, 0) @@ -1208,15 +1288,17 @@ struct State { result->SetResult(builtin->DetachResult()); builtin->Destroy(); + + ir.properties.Add(core::ir::Property::kAllowAnyInputAttachmentIndexType); } /// Handles SubgroupShuffle(), SubgroupShuffleDown(), SubgroupShuffleUp(), SubgroupShuffleXor() /// builtins. /// @param builtin the builtin call instruction - void SubgroupShuffle(core::ir::CoreBuiltinCall* builtin, bool clamp_subgroup_shuffle) { - TINT_IR_ASSERT(ir, builtin->Args().Length() == 2); + void SubgroupShuffle(core::ir::CoreBuiltinCall* builtin) { + TINT_IR_ASSERT(ir, builtin->Args().size() == 2); // The second argument is either 'id' , 'delta', or 'mask'. - // All must be bound by [0, 128) + // All must be bound by [0, subgroup_size) auto* arg2 = builtin->Args()[1]; // arg2 must be an unsigned integer scalar, so bitcast if necessary. if (arg2->Type()->IsSignedIntegerScalar()) { @@ -1226,21 +1308,24 @@ struct State { } /// Polyfill a `subgroupShuffleX` builtin call with one that has clamped the arg2 param - if (clamp_subgroup_shuffle) { - auto* shuffle_id = builtin->Args()[1]; - auto* mask_max_subgroup_size = - b.Constant(core::u32(tint::internal_limits::kMaxSubgroupSize - 1)); - b.InsertBefore(builtin, [&] { - auto* clamp_via_masking_and = b.And(shuffle_id, mask_max_subgroup_size); - builtin->SetArg(1, clamp_via_masking_and->Result()); + auto* shuffle_id = builtin->Args()[1]; + if (!subgroup_size_mask_) { + b.Append(ir.root_block, [&] { + subgroup_size_mask_ = + b.Var("tint_subgroup_size_mask"); }); } + b.InsertBefore(builtin, [&] { + auto* subgroup_size_mask = b.Load(subgroup_size_mask_); + auto* clamp_via_masking_and = b.And(shuffle_id, subgroup_size_mask); + builtin->SetArg(1, clamp_via_masking_and->Result()); + }); } /// Handle a SubgroupBroadcast() builtin. /// @param builtin the builtin call instruction void SubgroupBroadcast(core::ir::CoreBuiltinCall* builtin) { - TINT_IR_ASSERT(ir, builtin->Args().Length() == 2); + TINT_IR_ASSERT(ir, builtin->Args().size() == 2); auto* id = builtin->Args()[1]; TINT_IR_ASSERT(ir, id->Is()); @@ -1253,7 +1338,7 @@ struct State { /// Handle a QuadBroadcast() builtin. /// @param builtin the builtin call instruction void QuadBroadcast(core::ir::CoreBuiltinCall* builtin) { - TINT_IR_ASSERT(ir, builtin->Args().Length() == 2); + TINT_IR_ASSERT(ir, builtin->Args().size() == 2); auto* id = builtin->Args()[1]; TINT_IR_ASSERT(ir, id->Is()); @@ -1267,37 +1352,44 @@ struct State { /// @param builtin the builtin call instruction void SubgroupMatrixLoad(core::ir::CoreBuiltinCall* builtin) { b.InsertBefore(builtin, [&] { + const bool majorness_template = builtin->ExplicitTemplateParams().Length() == 2; auto* result_ty = builtin->Result()->Type()->As(); auto* p = builtin->Args()[0]; auto* offset = builtin->Args()[1]; - auto* col_major = builtin->Args()[2]->As(); - auto* stride = builtin->Args()[3]; + auto* stride = builtin->Args()[majorness_template ? 2 : 3]; auto* ptr = p->Type()->As(); auto* arr = ptr->StoreType()->As(); - auto* layout = b.Constant(u32(col_major->Value()->ValueAs() - ? SpvCooperativeMatrixLayoutColumnMajorKHR - : SpvCooperativeMatrixLayoutRowMajorKHR)); + bool col_major = true; + if (majorness_template) { + TINT_IR_ASSERT(ir, std::holds_alternative( + builtin->ExplicitTemplateParams()[1])); + col_major = std::get(builtin->ExplicitTemplateParams()[1]) == + core::Majorness::kColMajor; + } else { + col_major = builtin->Args()[2]->As()->Value()->ValueAs(); + } + auto* layout = b.Constant(u32(col_major ? SpvCooperativeMatrixLayoutColumnMajorKHR + : SpvCooperativeMatrixLayoutRowMajorKHR)); auto* memory_operand = Literal(u32(SpvMemoryAccessNonPrivatePointerMask)); // In SPIR-V `stride` and `offset` are related to the type of the input pointer, while // in WGSL they both mean the number of elements. When the subgroup matrix element type // is `i8` or `u8`, and the input array type is `i32` or `u32`, we need to convert the // `stride` and `offset` in WGSL into the ones in SPIR-V by dividing them with 4. - core::ir::Value* applied_stride = nullptr; - core::ir::Value* applied_offset = nullptr; + auto* applied_stride = stride; + auto* applied_offset = offset; if (result_ty->Type()->Size() == 1u && arr->ElemType()->Size() == 4u) { - auto* applied_stride_binary = - b.Binary(core::BinaryOp::kDivide, stride->Type(), stride, u32(4)); - applied_stride = applied_stride_binary->Result(); + if (!config.cooperative_matrix_stride_is_matrix_elements) { + auto* applied_stride_binary = + b.Binary(core::BinaryOp::kDivide, stride->Type(), stride, u32(4)); + applied_stride = applied_stride_binary->Result(); + } auto* applied_offset_binary = b.Binary(core::BinaryOp::kDivide, offset->Type(), offset, u32(4)); applied_offset = applied_offset_binary->Result(); - } else { - applied_stride = stride; - applied_offset = offset; } // Make a pointer to the first element of the array that we will load from. @@ -1307,7 +1399,7 @@ struct State { auto* call = b.CallWithResult( builtin->DetachResult(), spirv::BuiltinFn::kCooperativeMatrixLoad, src, layout, applied_stride, memory_operand); - call->SetExplicitTemplateParams(Vector{result_ty}); + call->SetExplicitTemplateParams(Vector{result_ty}); }); builtin->Destroy(); } @@ -1316,13 +1408,24 @@ struct State { /// @param builtin the builtin call instruction void SubgroupMatrixStore(core::ir::CoreBuiltinCall* builtin) { b.InsertBefore(builtin, [&] { + const bool majorness_template = builtin->ExplicitTemplateParams().Length() == 1; auto* p = builtin->Args()[0]; auto* offset = builtin->Args()[1]; auto* value = builtin->Args()[2]; auto* value_type = value->Type()->As(); - auto* col_major = builtin->Args()[3]->As(); - auto* stride = builtin->Args()[4]; + bool col_major = true; + if (majorness_template) { + TINT_IR_ASSERT(ir, std::holds_alternative( + builtin->ExplicitTemplateParams()[0])); + col_major = std::get(builtin->ExplicitTemplateParams()[0]) == + core::Majorness::kColMajor; + } else { + col_major = builtin->Args()[3]->As()->Value()->ValueAs(); + } + auto* layout = b.Constant(u32(col_major ? SpvCooperativeMatrixLayoutColumnMajorKHR + : SpvCooperativeMatrixLayoutRowMajorKHR)); + auto* stride = builtin->Args()[majorness_template ? 3 : 4]; auto* ptr = p->Type()->As(); auto* arr = ptr->StoreType()->As(); @@ -1331,28 +1434,24 @@ struct State { // in WGSL they both mean the number of elements. When the subgroup matrix element type // is `i8` or `u8`, and the input array type is `i32` or `u32`, we need to convert the // `stride` and `offset` in WGSL into the ones in SPIR-V by dividing them with 4. - core::ir::Value* applied_stride = nullptr; - core::ir::Value* applied_offset = nullptr; + auto* applied_stride = stride; + auto* applied_offset = offset; if (value_type->Type()->Size() == 1u && arr->ElemType()->Size() == 4u) { - auto* applied_stride_binary = - b.Binary(core::BinaryOp::kDivide, stride->Type(), stride, u32(4)); - applied_stride = applied_stride_binary->Result(); + if (!config.cooperative_matrix_stride_is_matrix_elements) { + auto* applied_stride_binary = + b.Binary(core::BinaryOp::kDivide, stride->Type(), stride, u32(4)); + applied_stride = applied_stride_binary->Result(); + } auto* applied_offset_binary = b.Binary(core::BinaryOp::kDivide, offset->Type(), offset, u32(4)); applied_offset = applied_offset_binary->Result(); - } else { - applied_stride = stride; - applied_offset = offset; } // Make a pointer to the first element of the array that we will write to. auto* elem_ptr = ty.ptr(ptr->AddressSpace(), arr->ElemType(), ptr->Access()); auto* dst = b.Access(elem_ptr, p, applied_offset); - auto* layout = b.Constant(u32(col_major->Value()->ValueAs() - ? SpvCooperativeMatrixLayoutColumnMajorKHR - : SpvCooperativeMatrixLayoutRowMajorKHR)); auto* memory_operand = Literal(u32(SpvMemoryAccessNonPrivatePointerMask)); b.Call(ty.void_(), spirv::BuiltinFn::kCooperativeMatrixStore, @@ -1365,9 +1464,8 @@ struct State { /// @param input_ty the type of the input matrices /// @param result_ty the type of the result matrix /// @returns the literal operands - ir::LiteralOperand* SubgroupMatrixMultiplyOperands( - const core::type::SubgroupMatrix* input_ty, - const core::type::SubgroupMatrix* result_ty) { + core::ir::Value* SubgroupMatrixMultiplyOperands(const core::type::SubgroupMatrix* input_ty, + const core::type::SubgroupMatrix* result_ty) { uint32_t operands = SpvCooperativeMatrixOperandsMaskNone; if (input_ty->Type()->IsSignedIntegerScalar()) { operands |= SpvCooperativeMatrixOperandsMatrixASignedComponentsKHRMask; @@ -1427,12 +1525,14 @@ struct State { auto* sm_ty = mat->Type()->As(); if (sm_ty->Type()->Is()) { scalar = b.CallExplicit( - ty.i8(), spirv::BuiltinFn::kSConvert, Vector{ty.i8()}, + ty.i8(), spirv::BuiltinFn::kSConvert, + Vector{ty.i8()}, b.Clamp(scalar, -128_i, 127_i)) ->Result(); } else if (sm_ty->Type()->Is()) { scalar = b.CallExplicit( - ty.u8(), spirv::BuiltinFn::kUConvert, Vector{ty.u8()}, + ty.u8(), spirv::BuiltinFn::kUConvert, + Vector{ty.u8()}, b.Clamp(scalar, 0_u, 255_u)) ->Result(); } @@ -1442,21 +1542,35 @@ struct State { }); builtin->Destroy(); } + + void AddSat(core::ir::CoreBuiltinCall* builtin) { + auto* type = builtin->Result()->Type(); + auto* str_ty = core::type::CreateAddCarryResult(ty, ir.symbols, type); + b.InsertBefore(builtin, [&] { + auto* call = b.Call(str_ty, BuiltinFn::kAddCarry, + builtin->Args()[0], builtin->Args()[1]); + auto* res = b.Access(type, call, 0_u); + auto* carry = b.Access(type, call, 1_u); + auto* eq = b.Equal(carry, b.Zero(type)); + core::ir::Value* sat = (type->Is() ? b.Splat(type, u32(0xffffffff)) + : b.Constant(u32(0xffffffff))); + b.CallWithResult(builtin->DetachResult(), + spirv::BuiltinFn::kSelect, eq, res, sat); + }); + builtin->Destroy(); + } }; } // namespace Result BuiltinPolyfill(core::ir::Module& ir, PolyfillConfig config) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllow8BitIntegers, - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, - }, - "spirv.BuiltinPolyfill")); + AssertValid(ir, "before spirv.BuiltinPolyfill"); State{ir, config}.Process(); + ir.properties.Add(core::ir::Property::kAllow8BitIntegers); + ir.properties.Add(core::ir::Property::kAllowNonCoreTypes); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.h index 1e30d931f..4e193504a 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/builtin_polyfill.h @@ -41,8 +41,9 @@ namespace tint::spirv::writer::raise { struct PolyfillConfig { bool use_vulkan_memory_model = false; SpvVersion version = SpvVersion::kSpv13; - bool subgroup_shuffle_clamped = false; bool texture_sample_compare_depth_cube_array = false; + bool texture_sample_compare_2d_polyfill = false; + bool cooperative_matrix_stride_is_matrix_elements = false; }; /// BuiltinPolyfill is a transform that replaces calls to builtins with polyfills and calls to diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/case_switch_to_if_else.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/case_switch_to_if_else.cc index cd76f5ddc..9e0e19a56 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/case_switch_to_if_else.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/case_switch_to_if_else.cc @@ -30,21 +30,15 @@ #include #include #include -#include #include "src/tint/lang/core/ir/builder.h" -#include "src/tint/lang/core/ir/control_instruction.h" #include "src/tint/lang/core/ir/exit_switch.h" #include "src/tint/lang/core/ir/if.h" #include "src/tint/lang/core/ir/instruction.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/switch.h" -#include "src/tint/lang/core/ir/traverse.h" #include "src/tint/lang/core/ir/validator.h" #include "src/tint/lang/core/ir/value.h" -#include "src/tint/lang/core/unary_op.h" -#include "src/tint/lang/wgsl/ast/case_selector.h" -#include "src/tint/utils/containers/transform.h" using namespace tint::core::fluent_types; // NOLINT @@ -52,12 +46,6 @@ namespace tint::spirv::writer::raise { namespace { -const core::ir::Capabilities kCaseSwitchToIfElseCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, -}; - /// PIMPL state for the transform, for a single function. struct State { /// The IR module. @@ -153,8 +141,7 @@ struct State { } // namespace Result CaseSwitchToIfElse(core::ir::Module& ir) { - TINT_CHECK_RESULT(core::ir::ValidateBeforeIfNeeded(ir, kCaseSwitchToIfElseCapabilities, - "spirv.CaseSwitchToIfElse")); + core::ir::AssertValid(ir, "before spirv.CaseSwitchToIfElse"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc index 4ab95c9f1..a56433f8c 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.cc @@ -58,7 +58,7 @@ struct State { // replicate the argument N times. auto* vec = construct->Result()->Type()->As(); if ((vec != nullptr) && // - construct->Args().Length() == 1 && + construct->Args().size() == 1 && construct->Args()[0]->Type()->Is()) { for (uint32_t i = 1; i < vec->Width(); i++) { construct->AppendArg(construct->Args()[0]); @@ -135,8 +135,7 @@ struct State { } // namespace Result ExpandImplicitSplats(core::ir::Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kExpandImplicitSplatsCapabilities, - "spirv.ExpandImplicitSplats")); + AssertValid(ir, "before spirv.ExpandImplicitSplats"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.h index 6cafd5e90..f8ef32043 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/expand_implicit_splats.h @@ -39,15 +39,6 @@ class Module; namespace tint::spirv::writer::raise { -/// The capabilities that the transform can support. -const core::ir::Capabilities kExpandImplicitSplatsCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, -}; - /// ExpandImplicitSplats is a transform that expands implicit vector splat operands in construct /// instructions and binary instructions where not supported by SPIR-V. /// @param module the module to transform diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.cc index b42a5203d..0cb1d7729 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.cc @@ -370,11 +370,12 @@ struct State { } // namespace Result ForkExplicitLayoutTypes(core::ir::Module& ir, SpvVersion version) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kForkExplicitLayoutTypesCapabilities, - "spirv.ForkExplicitLayoutTypes")); + AssertValid(ir, kForkExplicitLayoutTypesCapabilities, "before spirv.ForkExplicitLayoutTypes"); State{ir, version}.Process(); + ir.properties.Add(core::ir::Property::kAllowNonCoreTypes); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.h index 0b2ff8a97..cd6a18448 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/fork_explicit_layout_types.h @@ -43,12 +43,7 @@ namespace tint::spirv::writer::raise { /// The capabilities that the transform can support. const core::ir::Capabilities kForkExplicitLayoutTypesCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, core::ir::Capability::kLoosenValidationForShaderIO, - core::ir::Capability::kAllowPointSizeBuiltin, }; /// ForkExplicitLayoutTypes is a transform that forks array and structures types that are shared diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc index 1bf9f72cc..f1eacbe9a 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.cc @@ -163,8 +163,7 @@ struct State { } // namespace Result HandleMatrixArithmetic(core::ir::Module& ir) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kHandleMatrixArithmeticCapabilities, - "spirv.HandleMatrixArithmetic")); + AssertValid(ir, "before spirv.HandleMatrixArithmetic"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.h index 5ac41d8e7..191df3749 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/handle_matrix_arithmetic.h @@ -38,14 +38,6 @@ class Module; namespace tint::spirv::writer::raise { -// The capabilities that the transform can support. -const core::ir::Capabilities kHandleMatrixArithmeticCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, -}; - /// HandleMatrixArithmetic is a transform that converts arithmetic instruction that use matrix into /// SPIR-V intrinsics or polyfills. /// @param module the module to transform diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.cc index 6245c0c20..ee7be6ff1 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.cc @@ -27,8 +27,6 @@ #include "src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.h" -#include - #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/validator.h" @@ -75,8 +73,9 @@ struct State { use.instruction, [&](core::ir::Access* access) { b.InsertBefore(access, [&]() { - Vector indices_copy = access->Indices(); - auto* element_ptr = b.Access(element_ptr_ty, ba_ptr, indices_copy); + std::span indices_span = access->Indices(); + auto* element_ptr = b.Access(element_ptr_ty, ba_ptr, + Vector{indices_span}); b.LoadWithResult(access->DetachResult(), element_ptr); access->Destroy(); }); @@ -91,8 +90,7 @@ struct State { } // namespace Result KeepBindingArrayAsPointer(core::ir::Module& ir) { - TINT_CHECK_RESULT(core::ir::ValidateBeforeIfNeeded(ir, kKeepBindingArrayAsPointerCapabilities, - "spirv.KeepBindingArrayAsPointer")); + core::ir::AssertValid(ir, "before spirv.KeepBindingArrayAsPointer"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.h index 03c6b8a4b..f47555c9c 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/keep_binding_array_as_pointer.h @@ -38,12 +38,6 @@ class Module; namespace tint::spirv::writer::raise { -// The capabilities that the transform can support. -const core::ir::Capabilities kKeepBindingArrayAsPointerCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowNonCoreTypes, -}; - /// KeepBindingArrayAsPointer is a transform that ensures that binding_arrays are never stored by /// value but only used via a pointer to them. This is used to produce SPIR-V that's more similar to /// what drivers typically ingest where OpTypeArray is always kept as a pointer. diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/merge_return.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/merge_return.cc index e831e00b2..7b8448ef8 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/merge_return.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/merge_return.cc @@ -40,14 +40,6 @@ namespace tint::spirv::writer::raise { namespace { -// The capabilities that the transform can support. -const core::ir::Capabilities kMergeReturnCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, -}; - /// PIMPL state for the transform, for a single function. struct State { /// The IR module. @@ -227,7 +219,7 @@ struct State { exit_if->SetIf(cond); auto exit_args = exit_if->Args(); - if (!exit_args.IsEmpty()) { + if (!exit_args.empty()) { cond->SetResults(tint::Transform<8>(exit_args, [&](auto* arg) { // return b.InstructionResult(arg->Type()); })); @@ -271,8 +263,7 @@ struct State { } // namespace Result MergeReturn(core::ir::Module& ir) { - TINT_CHECK_RESULT( - core::ir::ValidateBeforeIfNeeded(ir, kMergeReturnCapabilities, "spirv.MergeReturn")); + core::ir::AssertValid(ir, "before spirv.MergeReturn"); // Process each function. for (auto& fn : ir.functions) { diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer.cc index 0755751d6..aefd0e564 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/pass_matrix_by_pointer.cc @@ -128,7 +128,7 @@ struct State { } // namespace Result PassMatrixByPointer(core::ir::Module& ir) { - TINT_CHECK_RESULT(core::ir::ValidateBeforeIfNeeded(ir, {}, "spirv.PassMatrixByPointer")); + core::ir::AssertValid(ir, "before spirv.PassMatrixByPointer"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/raise.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/raise.cc index e79982fc5..1f41cc4b1 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/raise.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/raise.cc @@ -34,6 +34,7 @@ #include "src/tint/lang/core/ir/transform/block_decorated_structs.h" #include "src/tint/lang/core/ir/transform/builtin_polyfill.h" #include "src/tint/lang/core/ir/transform/builtin_scalarize.h" +#include "src/tint/lang/core/ir/transform/collapse_subgroup_min_max.h" #include "src/tint/lang/core/ir/transform/combine_access_instructions.h" #include "src/tint/lang/core/ir/transform/conversion_polyfill.h" #include "src/tint/lang/core/ir/transform/decompose_access.h" @@ -43,6 +44,7 @@ #include "src/tint/lang/core/ir/transform/prepare_immediate_data.h" #include "src/tint/lang/core/ir/transform/preserve_padding.h" #include "src/tint/lang/core/ir/transform/prevent_infinite_loops.h" +#include "src/tint/lang/core/ir/transform/propagate_buffer_sizes.h" #include "src/tint/lang/core/ir/transform/remove_uniform_vector_component_loads.h" #include "src/tint/lang/core/ir/transform/resource_table.h" #include "src/tint/lang/core/ir/transform/robustness.h" @@ -75,6 +77,9 @@ Result Raise(core::ir::Module& module, const Options& options) { TINT_CHECK_RESULT( core::ir::transform::SubstituteOverrides(module, options.substitute_overrides_config)); + // Must come before robustness. + TINT_CHECK_RESULT(core::ir::transform::PropagateBufferSizes(module)); + tint::transform::multiplanar::BindingsMap multiplanar_map{}; RemapperData remapper_data{}; PopulateRemapperAndMultiplanarOptions(options, remapper_data, multiplanar_map); @@ -94,11 +99,8 @@ Result Raise(core::ir::Module& module, const Options& options) { TINT_CHECK_RESULT(core::ir::transform::PreventInfiniteLoops(module)); } - if (options.resource_table.has_value()) { - spirv::writer::raise::ResourceTableHelper helper; - TINT_CHECK_RESULT( - core::ir::transform::ResourceTable(module, options.resource_table.value(), &helper)); - } + spirv::writer::raise::ResourceTableHelper helper; + TINT_CHECK_RESULT(core::ir::transform::ResourceTable(module, options.resource_table, &helper)); // PrepareImmediateData must come before any transform that needs internal immediate data. core::ir::transform::PrepareImmediateDataConfig immediate_data_config; @@ -133,6 +135,8 @@ Result Raise(core::ir::Module& module, const Options& options) { core_polyfills.pack_4xu8_clamp = true; core_polyfills.pack_unpack_4x8_norm = options.workarounds.polyfill_pack_unpack_4x8_norm; core_polyfills.abs_signed_int = true; + core_polyfills.length_scalar_float = options.workarounds.polyfill_length_scalar_float; + core_polyfills.distance_scalar_float = options.workarounds.polyfill_distance_scalar_float; core_polyfills.subgroup_broadcast_f16 = options.workarounds.polyfill_subgroup_broadcast_f16; core_polyfills.saturate_as_min_max = options.workarounds.polyfill_saturate_as_min_max_f16; TINT_CHECK_RESULT(core::ir::transform::BuiltinPolyfill(module, core_polyfills)); @@ -141,8 +145,6 @@ Result Raise(core::ir::Module& module, const Options& options) { conversion_polyfills.ftoi = true; TINT_CHECK_RESULT(core::ir::transform::ConversionPolyfill(module, conversion_polyfills)); - TINT_CHECK_RESULT(core::ir::transform::MultiplanarExternalTexture(module, multiplanar_map)); - if (!options.disable_workgroup_init && !options.extensions.use_zero_initialize_workgroup_memory) { TINT_CHECK_RESULT(core::ir::transform::ZeroInitWorkgroupMemory(module)); @@ -154,9 +156,15 @@ Result Raise(core::ir::Module& module, const Options& options) { core::ir::transform::DirectVariableAccessOptions dva_options; dva_options.transform_function = true; dva_options.transform_private = true; - dva_options.transform_handle = options.workarounds.dva_transform_handle; + dva_options.transform_handle = options.workarounds.dva_transform_handle + ? core::ir::transform::HandleTransformLevel::kFull + : core::ir::transform::HandleTransformLevel::kExternal; TINT_CHECK_RESULT(core::ir::transform::DirectVariableAccess(module, dva_options)); + // Must come after DirectVariableAccess as we need all ExternalTextures to have their functions + // flattened. + TINT_CHECK_RESULT(core::ir::transform::MultiplanarExternalTexture(module, multiplanar_map)); + // Fixup loads of binding_arrays of handles that may have been introduced by // DirectVariableAccess (DVA). Vulkan drivers that need DVA of handle expect binding_arrays to // stay as pointer and many mishandle by-value binding_arrays. @@ -171,12 +179,14 @@ Result Raise(core::ir::Module& module, const Options& options) { TINT_CHECK_RESULT(core::ir::transform::Bgra8UnormPolyfill(module)); - if (!options.extensions.use_uniform_buffers) { - // DecomposeAccess must come before BlockDecoratedStructs, which will wrap the - // uniform variable in a structure. - core::ir::transform::DecomposeAccessOptions decompose_config{.uniform = true}; - TINT_CHECK_RESULT(core::ir::transform::DecomposeAccess(module, decompose_config)); - } else { + // DecomposeAccess must come before BlockDecoratedStructs, which will wrap + // buffer resource variables in a structure. + // Uniform buffers are only unconditionally decomposed if the implementation does not support + // uniform buffer standard layout. Otherwise, only buffer type variables are decomposed. + core::ir::transform::DecomposeAccessOptions decompose_config{ + .uniform = !options.extensions.use_uniform_buffers}; + TINT_CHECK_RESULT(core::ir::transform::DecomposeAccess(module, decompose_config)); + if (options.extensions.use_uniform_buffers) { TINT_CHECK_RESULT(core::ir::transform::Std140(module)); } TINT_CHECK_RESULT(core::ir::transform::BlockDecoratedStructs(module)); @@ -197,30 +207,37 @@ Result Raise(core::ir::Module& module, const Options& options) { TINT_CHECK_RESULT(core::ir::transform::DemoteToHelper(module)); } + if (options.workarounds.collapse_subgroup_min_max) { + TINT_CHECK_RESULT(core::ir::transform::CollapseSubgroupMinMax(module)); + } + raise::PolyfillConfig config = { .use_vulkan_memory_model = options.extensions.use_vulkan_memory_model, .version = options.spirv_version, - .subgroup_shuffle_clamped = options.workarounds.subgroup_shuffle_clamped, .texture_sample_compare_depth_cube_array = - options.workarounds.texture_sample_compare_depth_cube_array}; + options.workarounds.texture_sample_compare_depth_cube_array, + .texture_sample_compare_2d_polyfill = + options.workarounds.texture_sample_compare_2d_polyfill, + .cooperative_matrix_stride_is_matrix_elements = + options.workarounds.cooperative_matrix_stride_is_matrix_elements, + }; TINT_CHECK_RESULT(raise::BuiltinPolyfill(module, config)); TINT_CHECK_RESULT(raise::ExpandImplicitSplats(module)); core::ir::transform::BuiltinScalarizeConfig scalarize_config{ - .scalarize_clamp = options.workarounds.scalarize_max_min_clamp, - .scalarize_max = options.workarounds.scalarize_max_min_clamp, - .scalarize_min = options.workarounds.scalarize_max_min_clamp}; + .scalarize_min_max_clamp = options.workarounds.scalarize_max_min_clamp, + }; TINT_CHECK_RESULT(core::ir::transform::BuiltinScalarize(module, scalarize_config)); core::ir::transform::SignedIntegerPolyfillConfig signed_integer_cfg{ .signed_negation = true, .signed_arithmetic = true, .signed_shiftleft = true}; TINT_CHECK_RESULT(core::ir::transform::SignedIntegerPolyfill(module, signed_integer_cfg)); - // AMD mesa front end optimizer bug for unary negation and abs. - // Fixed in 25.3 - See crbug.com/448294721 + // AMD Mesa front end optimizer bug for unary f32 and f16 negation and abs. + // Fixed in 25.3 - See crbug.com/448294721 and crbug.com/500099471 raise::UnaryPolyfillConfig unary_polyfill_cfg = { - .polyfill_f32_negation = options.workarounds.polyfill_unary_f32_negation, - .polyfill_f32_abs = options.workarounds.polyfill_f32_abs}; + .polyfill_float_negation = options.workarounds.polyfill_float_negation, + .polyfill_float_abs = options.workarounds.polyfill_float_abs}; TINT_CHECK_RESULT(raise::UnaryPolyfill(module, unary_polyfill_cfg)); @@ -238,6 +255,7 @@ Result Raise(core::ir::Module& module, const Options& options) { .emit_vertex_point_size = options.emit_vertex_point_size, .polyfill_f16_io = !options.extensions.use_storage_input_output_16, .polyfill_pixel_center = options.polyfill_pixel_center, + .multisampled_framebuffer_fetch = options.multisampled_framebuffer_fetch, .depth_range_offsets = options.depth_range_offsets, })); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.cc index 1bf7f8f8c..6f8de32cb 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.cc @@ -94,9 +94,7 @@ struct State { } // namespace Result RemoveUnreachableInLoopContinuing(core::ir::Module& ir) { - TINT_CHECK_RESULT( - core::ir::ValidateBeforeIfNeeded(ir, kRemoveUnreachableInLoopContinuingCapabilities, - "spirv.RemoveUnreachableInLoopContinuing")); + core::ir::AssertValid(ir, "before spirv.RemoveUnreachableInLoopContinuing"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.h index 9728cacf9..4d67c930e 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/remove_unreachable_in_loop_continuing.h @@ -38,14 +38,6 @@ class Module; namespace tint::spirv::writer::raise { -// The capabilities that the transform can support. -const core::ir::Capabilities kRemoveUnreachableInLoopContinuingCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, -}; - /// RemoveUnreachableInLoopContinuing is a transform that replaces unreachable statements that are /// nested inside a loop continuing block, as SPIR-V's structured control flow rules prohibit this. /// @param module the module to transform diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/resource_table_helper.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/resource_table_helper.cc index b25c9b36a..6c567ee1d 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/resource_table_helper.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/resource_table_helper.cc @@ -27,7 +27,6 @@ #include "src/tint/lang/spirv/writer/raise/resource_table_helper.h" -#include "src/tint/lang/core/type/pointer.h" #include "src/tint/lang/core/type/resource_table.h" #include "src/tint/lang/core/type/resource_type.h" @@ -46,6 +45,12 @@ Hashmap ResourceTableHelper::Generat for (auto& type : types) { auto* t = core::type::ResourceTypeToType(b.ir.Types(), type); + // The defaults can include both filterable/unfilterable variants, but they collapse to the + // same type in WGSL, so only emit them once. + if (res.Contains(t)) { + continue; + } + auto* spv_ty = b.ir.Types().Get(t); auto* v = b.Var(b.ir.Types().ptr(handle, spv_ty)); v->SetBindingPoint(bp.group, bp.binding); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.cc index 9a7026f4a..3149c44f2 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.cc @@ -33,6 +33,7 @@ #include #include +#include "spirv/unified1/spirv.h" #include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/fluent_types.h" #include "src/tint/lang/core/ir/builder.h" @@ -42,6 +43,7 @@ #include "src/tint/lang/spirv/builtin_fn.h" #include "src/tint/lang/spirv/ir/builtin_call.h" #include "src/tint/lang/spirv/type/image.h" +#include "src/tint/lang/spirv/type/literal.h" #include "src/tint/utils/ice/ice.h" using namespace tint::core::fluent_types; // NOLINT @@ -61,6 +63,8 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { /// The output variables. Vector output_vars; + Vector input_indices; + /// The configuration options. const ShaderIOConfig& config; @@ -68,45 +72,40 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { core::ir::Value* vert_out_position = nullptr; // IO index for vertex position emulation interpolant - std::optional center_pos_vert_idx; + std::optional center_pos_vert_idx = std::nullopt; // IO index for fragment position emulation interpolant - std::optional center_pos_frag_idx; + std::optional center_pos_frag_idx = std::nullopt; + + // IO index for sample_index + std::optional sample_index_idx = std::nullopt; + + std::optional global_invocation_index_index; + std::optional global_invocation_id_index; + std::optional workgroup_index_index; + std::optional workgroup_id_index; + std::optional num_workgroups_index; /// Constructor StateImpl(core::ir::Module& mod, core::ir::Function* f, const ShaderIOConfig& cfg) - : ShaderIOBackendState(mod, f), config(cfg) {} + : ShaderIOBackendState(mod, f), config(cfg) { + if (auto wgsize = func->WorkgroupSizeAsConst()) { + workgroup_size = wgsize; + } + } /// Destructor ~StateImpl() override {} /// Add a new interpolant that will be used to emulate the position builtin as if it always is /// pixel centered. - /// @param entries the entries to emit /// @param addrspace the address to use for the global variables - uint32_t AddCenterPosInterpolant(Vector& entries, - core::AddressSpace addrspace) { - // Verbose way of finding the smallest free location (id). This of course needs to be the - // same id value for both vertex and fragment. - std::set existing_locations; - for (auto io : entries) { - if (io.attributes.location.has_value()) { - existing_locations.insert(io.attributes.location.value()); - } - } - uint32_t free_location = 0u; - // We only need to search through existing_locations.size + 1 because either we will simply - // add an index to the end or there will be a hole in the range of locations - for (uint32_t i = 0u; i < (existing_locations.size() + 1); i++) { - if (existing_locations.find(i) == existing_locations.end()) { - free_location = i; - break; - } - } - + uint32_t AddCenterPosInterpolant(core::AddressSpace addrspace) { + // For our 'position' -> 'FragCoord' polyfill we must use 'perspective' because + // 'interpolateAtOffset' may not be supported for 'linear'. auto io_attrib = core::IOAttributes{ - .location = free_location, - .interpolation = core::Interpolation{.type = core::InterpolationType::kLinear, + .location = config.polyfill_pixel_center.value(), + .interpolation = core::Interpolation{.type = core::InterpolationType::kPerspective, .sampling = core::InterpolationSampling::kCenter}}; if (addrspace == core::AddressSpace::kOut) { @@ -127,12 +126,12 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { core::Access access, const char* name_suffix) { if (func->IsVertex() && addrspace == core::AddressSpace::kOut && - config.polyfill_pixel_center) { - center_pos_vert_idx = AddCenterPosInterpolant(entries, addrspace); + config.polyfill_pixel_center.has_value()) { + center_pos_vert_idx = AddCenterPosInterpolant(addrspace); } else if (func->IsFragment() && addrspace == core::AddressSpace::kIn && - config.polyfill_pixel_center) { - center_pos_frag_idx = AddCenterPosInterpolant(entries, addrspace); + config.polyfill_pixel_center.has_value()) { + center_pos_frag_idx = AddCenterPosInterpolant(addrspace); } for (auto io : entries) { @@ -152,6 +151,31 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { io.attributes.interpolation = core::Interpolation{core::InterpolationType::kFlat}; } + + uint32_t index = static_cast(input_indices.Length()); + switch (io.attributes.builtin.value()) { + // Record an index for polyfilled inputs. + case core::BuiltinValue::kGlobalInvocationIndex: + global_invocation_index_index = index; + input_indices.Push(index); + continue; + // Save the indices of the builtins below for use in polyfills. + case core::BuiltinValue::kWorkgroupIndex: + workgroup_index_index = index; + input_indices.Push(index); + continue; + case core::BuiltinValue::kGlobalInvocationId: + global_invocation_id_index = index; + break; + case core::BuiltinValue::kWorkgroupId: + workgroup_id_index = index; + break; + case core::BuiltinValue::kNumWorkgroups: + num_workgroups_index = index; + break; + default: + break; + } } if (io.attributes.location) { name << "_loc" << io.attributes.location.value(); @@ -173,10 +197,15 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { // Color becomes an InputAttachment in the handle space if (io.attributes.color) { - auto sample_ty = store_type->DeepestElement(); + auto* sample_ty = store_type->DeepestElement(); + if (sample_ty->Is()) { + sample_ty = ty.f32(); + } store_type = ty.Get( sample_ty, type::Dim::kSubpassData, type::Depth::kNotDepth, - type::Arrayed::kNonArrayed, type::Multisampled::kSingleSampled, + type::Arrayed::kNonArrayed, + config.multisampled_framebuffer_fetch ? type::Multisampled::kMultisampled + : type::Multisampled::kSingleSampled, type::Sampled::kReadWriteOpCompatible, core::TexelFormat::kUndefined, access); new_addrspace = core::AddressSpace::kHandle; @@ -190,6 +219,8 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { io.attributes.input_attachment_index = io.attributes.color; io.attributes.color = std::nullopt; + + ir.properties.Add(core::ir::Property::kAllowAnyInputAttachmentIndexType); } // Create an IO variable and add it to the root block. @@ -198,31 +229,66 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { var->SetAttributes(io.attributes); ir.root_block->Append(var); + input_indices.Push(static_cast(vars.Length())); vars.Push(var); } } /// @copydoc ShaderIO::BackendState::FinalizeInputs - Vector FinalizeInputs() override { + Result> FinalizeInputs() override { + if (config.multisampled_framebuffer_fetch) { + sample_index_idx = + RequireBuiltinInput(core::BuiltinValue::kSampleIndex, ty.u32(), "sample_idx"); + } + + // The following builtin values are polyfilled using other builtin values: + // * workgroup_index - workgroup_id and num_workgroups + // * global_invocation_index - global_invocation_id, num_workgroups (and workgroup size) + const bool has_global_invocation_index = + HasBuiltinInput(core::BuiltinValue::kGlobalInvocationIndex); + const bool has_workgroup_index = HasBuiltinInput(core::BuiltinValue::kWorkgroupIndex); + const bool needs_workgroup_id = has_workgroup_index; + if (needs_workgroup_id) { + RequireBuiltinInput(core::BuiltinValue::kWorkgroupId, ty.vec3u(), "workgroup_id"); + } + const bool needs_num_workgroups = has_workgroup_index || has_global_invocation_index; + if (needs_num_workgroups) { + RequireBuiltinInput(core::BuiltinValue::kNumWorkgroups, ty.vec3u(), "num_workgroups"); + } + const bool needs_global_invocation_id = has_global_invocation_index; + if (needs_global_invocation_id) { + RequireBuiltinInput(core::BuiltinValue::kGlobalInvocationId, ty.vec3u(), + "global_invocation_id"); + } + MakeVars(input_vars, inputs, core::AddressSpace::kIn, core::Access::kRead, "_Input"); - return tint::Empty; + return Vector{}; } /// @copydoc ShaderIO::BackendState::FinalizeOutputs - const core::type::Type* FinalizeOutputs() override { + Result FinalizeOutputs() override { MakeVars(output_vars, outputs, core::AddressSpace::kOut, core::Access::kWrite, "_Output"); return ty.void_(); } /// @copydoc ShaderIO::BackendState::GetInput core::ir::Value* GetInput(core::ir::Builder& builder, uint32_t idx) override { + if (idx == global_invocation_index_index) { + return PolyfillGlobalInvocationIndex(builder, global_invocation_id_index.value(), + num_workgroups_index.value()); + } + if (idx == workgroup_index_index) { + return PolyfillWorkgroupIndex(builder, workgroup_id_index.value(), + num_workgroups_index.value()); + } // Load the input from the global variable declared earlier. auto* ptr = ty.ptr(core::AddressSpace::kIn, inputs[idx].type, core::Access::kRead); - auto* from = input_vars[idx]->Result(); + auto input_index = input_indices[idx]; + auto* from = input_vars[input_index]->Result(); // SampleMask becomes an array for SPIR-V, so load from the first element. if (inputs[idx].attributes.builtin == core::BuiltinValue::kSampleMask) { - from = builder.Access(ptr, input_vars[idx], 0_u)->Result(); + from = builder.Access(ptr, input_vars[input_index], 0_u)->Result(); } core::ir::Value* value = builder.Load(from)->Result(); @@ -237,32 +303,38 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { builtin_args.Push(value); builtin_args.Push(coords); + if (config.multisampled_framebuffer_fetch) { + builtin_args.Push( + builder.Constant(builder.ir.constant_values.Get>( + ty.Get(), u32(SpvImageOperandsSampleMask)))); + builtin_args.Push(builder.Load(input_vars[sample_index_idx.value()])->Result()); + } + // Call the builtin. - value = builder - .Call(ty.vec4(inputs[idx].type->DeepestElement()), - spirv::BuiltinFn::kImageRead, - std::move(builtin_args)) - ->Result(); + auto* sampled_ty = builtin_args[0]->Type()->As()->GetSampledType(); + value = + builder + .Call(ty.vec4(sampled_ty), spirv::BuiltinFn::kImageRead, + std::move(builtin_args)) + ->Result(); auto* orig_ty = inputs[idx].type; - if (orig_ty->IsAnyOf()) { - value = builder.Swizzle(orig_ty, value, {0})->Result(); - } else { - auto* vec = orig_ty->As(); - TINT_IR_ASSERT(ir, vec); - - if (vec->Width() != 4) { - Vector indices; - for (uint32_t i = 0; i < vec->Width(); ++i) { - indices.Push(i); - } - value = builder.Swizzle(orig_ty, value, indices)->Result(); + uint32_t width = + orig_ty->Is() ? orig_ty->As()->Width() : 1; + if (width != 4) { + Vector indices; + for (uint32_t i = 0; i < width; ++i) { + indices.Push(i); } + value = + builder.Swizzle(ty.MatchWidth(sampled_ty, orig_ty), value, indices)->Result(); } } // Convert f32 values to f16 values if needed. - if (config.polyfill_f16_io && inputs[idx].type->DeepestElement()->Is()) { + bool should_convert_f16 = + config.polyfill_f16_io || inputs[idx].attributes.color.has_value(); + if (should_convert_f16 && inputs[idx].type->DeepestElement()->Is()) { value = builder.Convert(inputs[idx].type, value)->Result(); } @@ -274,10 +346,26 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { auto p5_const = builder.Constant(0.5_f); auto* plus_p5 = builder.Add(floor_xy, builder.Splat(ty.vec2f(), p5_const)); - auto* xyzw_from_user_center = builder.Load(input_vars[center_pos_frag_idx.value()]); + auto center_idx = input_indices[center_pos_frag_idx.value()]; + // Use interpolateAtOffset to get the pixel center. The Vulkan spec does not guarantee + // that 'center' interpolation sampling will actually be the pixel center when sample + // shading is enabled. In fact, it suggests that it will be at sample location. However + // it appears that this is not consistent across all devices. + // See: https://docs.vulkan.org/refpages/latest/refpages/source/FragCoord.html + auto* xyzw_from_user_center = builder.Call( + ty.vec4f(), spirv::BuiltinFn::kInterpolateAtOffset, input_vars[center_idx], + builder.Splat(ty.vec2f(), 0_f)); - auto* user_center_z = builder.Swizzle(ty.f32(), xyzw_from_user_center, {2}); - auto* user_center_w = builder.Swizzle(ty.f32(), xyzw_from_user_center, {3}); + auto* interpolated_z = builder.Swizzle(ty.f32(), xyzw_from_user_center, {2}); + auto* interpolated_w = builder.Swizzle(ty.f32(), xyzw_from_user_center, {3}); + + // This is the perspective divide (distinct from perspective correct interpolation). + // Technically we would be doing it on 'x' and 'y' components as well but we are using + // the values from 'FragCoord' to avoid having to know viewport size. + auto* user_center_z = builder.Divide(interpolated_z, interpolated_w); + + // The expected value for component 'w' of 'FragCoord' is actually 1/w. + auto* user_center_w = builder.Divide(1_f, interpolated_w); auto* viewport_user_center_z = ViewportMappedFragDepth(builder, user_center_z->Result()); @@ -316,15 +404,7 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { if (center_pos_vert_idx.has_value() && center_pos_vert_idx == idx) { // Special center position polyfilled from within vertex shader. TINT_IR_ASSERT(ir, vert_out_position); - auto one_div_w = - builder.Divide(1_f, builder.Swizzle(ty.f32(), vert_out_position, {3u})); - auto z_div_w = - builder.Multiply(one_div_w, builder.Swizzle(ty.f32(), vert_out_position, {2u})); - value = - builder - .Construct(ty.vec4f(), builder.Swizzle(ty.vec2f(), vert_out_position, {0, 1}), - z_div_w, one_div_w) - ->Result(); + value = vert_out_position; } // Clamp frag_depth values if necessary. @@ -385,11 +465,12 @@ struct StateImpl : core::ir::transform::ShaderIOBackendState { } // namespace Result ShaderIO(core::ir::Module& ir, const ShaderIOConfig& config) { - TINT_CHECK_RESULT(ValidateBeforeIfNeeded(ir, kShaderIOCapabilities, "spirv.ShaderIO")); + AssertValid(ir, kShaderIOCapabilities, "before spirv.ShaderIO"); - core::ir::transform::RunShaderIOBase(ir, [&](core::ir::Module& mod, core::ir::Function* func) { - return std::make_unique(mod, func, config); - }); + TINT_CHECK_RESULT(core::ir::transform::RunShaderIOBase( + ir, [&](core::ir::Module& mod, core::ir::Function* func) { + return std::make_unique(mod, func, config); + })); return Success; } diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.h index 626589309..6b0d0736c 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/shader_io.h @@ -44,10 +44,6 @@ namespace tint::spirv::writer::raise { /// The capabilities that the transform can support. const core::ir::Capabilities kShaderIOCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, core::ir::Capability::kLoosenValidationForShaderIO, }; @@ -64,7 +60,9 @@ struct ShaderIOConfig { /// true if f16 IO types should be replaced with f32 types and converted bool polyfill_f16_io = false; /// true if we should force pixel centers via polyfill when multi-sampling. - bool polyfill_pixel_center = false; + std::optional polyfill_pixel_center = std::nullopt; + /// true if the framebuffer fetch should be multisampled + bool multisampled_framebuffer_fetch = false; /// offsets for clamping frag depth std::optional depth_range_offsets{}; }; diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.cc index 76e055277..a7b6f3d45 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.cc @@ -30,6 +30,7 @@ #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/validator.h" +#include "src/tint/utils/ice/ice.h" #include "src/tint/utils/result.h" using namespace tint::core::fluent_types; // NOLINT @@ -46,36 +47,89 @@ struct State { core::type::Manager& ty{ir.Types()}; void Process() { - Vector unary_worklist; - Vector builtin_worklist; + // Find all f16 instructions and promote them to f32. + Vector f16_unary_worklist; + Vector f16_builtin_worklist; for (auto* inst : ir.Instructions()) { if (auto* unary = inst->As()) { - if (config.polyfill_f32_negation && unary->Op() == core::UnaryOp::kNegation && - unary->Result()->Type()->DeepestElement()->Is()) { - unary_worklist.Push(unary); + if (config.polyfill_float_negation && unary->Op() == core::UnaryOp::kNegation && + unary->Result()->Type()->DeepestElement()->Is()) { + f16_unary_worklist.Push(unary); } } else if (auto* builtin = inst->As()) { - if (config.polyfill_f32_abs && builtin->Func() == core::BuiltinFn::kAbs && - builtin->Result()->Type()->DeepestElement()->Is()) { - builtin_worklist.Push(builtin); + if (config.polyfill_float_abs && builtin->Func() == core::BuiltinFn::kAbs && + builtin->Result()->Type()->DeepestElement()->Is()) { + f16_builtin_worklist.Push(builtin); } } } - for (auto* unary : unary_worklist) { + for (auto* unary : f16_unary_worklist) { + TINT_ASSERT(unary->Op() == core::UnaryOp::kNegation); + PromoteToF32(unary); + } + for (auto* builtin : f16_builtin_worklist) { + TINT_ASSERT(builtin->Func() == core::BuiltinFn::kAbs); + PromoteToF32(builtin); + } + + // Find all f32 instructions (including newly promoted ones) and polyfill them. + Vector f32_unary_worklist; + Vector f32_builtin_worklist; + for (auto* inst : ir.Instructions()) { + if (auto* unary = inst->As()) { + if (config.polyfill_float_negation && unary->Op() == core::UnaryOp::kNegation && + unary->Result()->Type()->DeepestElement()->Is()) { + f32_unary_worklist.Push(unary); + } + } else if (auto* builtin = inst->As()) { + if (config.polyfill_float_abs && builtin->Func() == core::BuiltinFn::kAbs && + builtin->Result()->Type()->DeepestElement()->Is()) { + f32_builtin_worklist.Push(builtin); + } + } + } + + for (auto* unary : f32_unary_worklist) { + TINT_ASSERT(unary->Op() == core::UnaryOp::kNegation); PolyfillF32Negation(unary); } - for (auto* builtin : builtin_worklist) { + for (auto* builtin : f32_builtin_worklist) { + TINT_ASSERT(builtin->Func() == core::BuiltinFn::kAbs); PolyfillF32Abs(builtin); } } + void PromoteToF32(core::ir::Unary* unary) { + auto* val = unary->Val(); + auto* type = val->Type(); + b.InsertBefore(unary, [&] { + auto* f32_ty = ty.MatchWidth(ty.f32(), type); + auto* f32_val = b.Convert(f32_ty, val); + auto* f32_neg = b.Negation(f32_val); + b.ConvertWithResult(unary->DetachResult(), f32_neg->Result()); + }); + unary->Destroy(); + } + + void PromoteToF32(core::ir::CoreBuiltinCall* builtin) { + auto* val = builtin->Args()[0]; + auto* type = val->Type(); + b.InsertBefore(builtin, [&] { + auto* f32_ty = ty.MatchWidth(ty.f32(), type); + auto* f32_val = b.Convert(f32_ty, val); + auto* f32_abs = b.Call(f32_ty, core::BuiltinFn::kAbs, f32_val); + b.ConvertWithResult(builtin->DetachResult(), f32_abs->Result()); + }); + builtin->Destroy(); + } + void PolyfillF32Negation(core::ir::Unary* unary) { auto* val = unary->Val(); auto* type = val->Type(); - // AMD mesa front end optimizer bug for unary negation and abs. - // Fixed in 25.3 - See crbug.com/448294721 + // AMD Mesa front end optimizer bug for unary f32 (and indirectly f16) negation and abs. + // Fixed in 25.3 - See crbug.com/448294721 and crbug.com/500099471 // Note we use bitcast as a hammer to avoid the optimizer seeing through other possible // workarounds. b.InsertBefore(unary, [&] { @@ -92,8 +146,8 @@ struct State { auto* val = builtin->Args()[0]; auto* type = val->Type(); - // AMD mesa front end optimizer bug for unary negation and abs. - // Fixed in 25.3 - See crbug.com/448294721 + // AMD Mesa front end optimizer bug for unary f32 (and indirectly f16) negation and abs. + // Fixed in 25.3 - See crbug.com/500099471 // Note we use bitcast as a hammer to avoid the optimizer seeing through other possible // workarounds. b.InsertBefore(builtin, [&] { @@ -110,8 +164,7 @@ struct State { } // namespace Result UnaryPolyfill(core::ir::Module& module, const UnaryPolyfillConfig& config) { - TINT_CHECK_RESULT( - ValidateBeforeIfNeeded(module, kPolyfillUnaryCapabilities, "spirv.UnaryPolyfill")); + AssertValid(module, "before spirv.UnaryPolyfill"); State{module, config}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.h index 36bf2f6cc..8af105cfc 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/unary_polyfill.h @@ -38,20 +38,12 @@ class Module; namespace tint::spirv::writer::raise { -// The capabilities that the transform can support. -const core::ir::Capabilities kPolyfillUnaryCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, -}; - /// Configuration for the UnaryPolyfill transform. struct UnaryPolyfillConfig { - /// If true, polyfill f32 negation with bit manipulation. - bool polyfill_f32_negation = false; - /// If true, polyfill f32 abs with sign() * x. - bool polyfill_f32_abs = false; + /// If true, polyfill f32 and f16 negation with bit manipulation. + bool polyfill_float_negation = false; + /// If true, polyfill f32 and f16 abs. + bool polyfill_float_abs = false; }; /// UnaryPolyfill is a transform that replaces unary instructions with polyfills. diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc index eebc14fd5..6f8d96cd2 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.cc @@ -31,7 +31,6 @@ #include "src/tint/lang/core/ir/builder.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/lang/core/ir/validator.h" -#include "src/tint/lang/core/type/array.h" #include "src/tint/lang/core/type/matrix.h" #include "src/tint/lang/core/type/pointer.h" #include "src/tint/lang/core/type/vector.h" @@ -92,7 +91,7 @@ struct State { void WalkAccessChain(core::ir::Access* access, CALLBACK&& callback) { auto indices = access->Indices(); auto* type = access->Object()->Type(); - for (size_t i = 0; i < indices.Length(); i++) { + for (size_t i = 0; i < indices.size(); i++) { if (callback(i, indices[i], type) == Action::kStop) { break; } @@ -159,8 +158,9 @@ struct State { // If the access starts with at least one constant index, extract the source of the // first dynamic access to avoid copying the whole object. if (to_replace.first_dynamic_index > 0) { - PartialAccess partial_access = { - access->Object(), access->Indices().Truncate(to_replace.first_dynamic_index)}; + auto indices = Vector{ + access->Indices().subspan(0, to_replace.first_dynamic_index)}; + auto partial_access = PartialAccess{access->Object(), indices}; source_object = source_object_to_value.GetOrAdd(partial_access, [&]() -> core::ir::Value* { // If the source is a constant, then the partial access will also produce a @@ -214,7 +214,7 @@ struct State { // Create a new access instruction using the new variable as the source. Vector indices{ - access->Indices().Offset(to_replace.first_dynamic_index)}; + access->Indices().subspan(to_replace.first_dynamic_index)}; const core::type::Type* access_type = access->Result()->Type(); core::ir::Value* vector_index = nullptr; if (to_replace.vector_access_type) { @@ -249,8 +249,7 @@ struct State { } // namespace Result VarForDynamicIndex(core::ir::Module& ir) { - TINT_CHECK_RESULT(core::ir::ValidateBeforeIfNeeded(ir, kVarForDynamicIndexCapabilities, - "spirv.VarForDynamicIndex")); + core::ir::AssertValid(ir, kVarForDynamicIndexCapabilities, "before spirv.VarForDynamicIndex"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.h b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.h index f7452f018..33559b67f 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/raise/var_for_dynamic_index.h @@ -40,12 +40,7 @@ namespace tint::spirv::writer::raise { /// The capabilities that the transform can support. const core::ir::Capabilities kVarForDynamicIndexCapabilities{ - core::ir::Capability::kAllowDuplicateBindings, - core::ir::Capability::kAllowAnyInputAttachmentIndexType, - core::ir::Capability::kAllowNonCoreTypes, - core::ir::Capability::kAllow8BitIntegers, core::ir::Capability::kLoosenValidationForShaderIO, - core::ir::Capability::kAllowPointSizeBuiltin, }; /// VarForDynamicIndex is a transform that copies array and matrix values that are dynamically diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/writer.cc b/3rdparty/dawn/src/tint/lang/spirv/writer/writer.cc index 3ca5811b6..b394a792c 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/writer.cc +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/writer.cc @@ -34,17 +34,22 @@ #include "src/tint/lang/core/ir/referenced_module_vars.h" #include "src/tint/lang/core/ir/validator.h" #include "src/tint/lang/core/ir/var.h" +#include "src/tint/lang/core/type/f16.h" #include "src/tint/lang/core/type/pointer.h" +#include "src/tint/lang/core/type/struct.h" #include "src/tint/lang/core/type/u16.h" #include "src/tint/lang/spirv/writer/common/option_helpers.h" #include "src/tint/lang/spirv/writer/printer/printer.h" #include "src/tint/lang/spirv/writer/raise/raise.h" +#include "src/tint/utils/internal_limits.h" // Included by 'ast_printer.h', included again here for './tools/run gen' track the dependency. #include "spirv/unified1/spirv.h" // IWYU pragma: export namespace tint::spirv::writer { +namespace { + Result CanGenerate(const core::ir::Module& ir, const Options& options) { // The enum is accessible in the API so ensure we have a valid value. switch (options.spirv_version) { @@ -63,11 +68,11 @@ Result CanGenerate(const core::ir::Module& ir, const Options& optio return Failure("using subgroup matrices requires the Vulkan Memory Model"); } } - if (ty->Is()) { - return Failure("buffers are not supported by the SPIR-V backend"); - } - if (ty->Is()) { - return Failure("16-bit unsigned integers are not supported by the SPIR-V backend"); + if (auto* str = ty->As()) { + auto res = str->PaddingWithinLimit(); + if (res != Success) { + return res.Failure(); + } } } @@ -77,18 +82,6 @@ Result CanGenerate(const core::ir::Module& ir, const Options& optio if (options.remapped_entry_point_name.find('\0') != std::string::npos) { return Failure("remapped entry point name contains null character"); } - - // Check for multiple entry points. - // TODO(375388101): Remove this check when SingleEntryPoint is part of the backend. - bool has_entry_point = false; - for (auto& func : ir.functions) { - if (func->IsEntryPoint()) { - if (has_entry_point) { - return Failure("module must only contain a single entry point"); - } - has_entry_point = true; - } - } } core::ir::Function* ep_func = nullptr; @@ -107,6 +100,36 @@ Result CanGenerate(const core::ir::Module& ir, const Options& optio return Failure("entry point not found"); } + // Check for unsupported shader IO attributes. + auto check_io_attributes = [&](const core::IOAttributes& attributes) -> Result { + if (attributes.location.has_value() && + attributes.location.value() >= tint::internal_limits::kMaxLocations) { + return Failure("location(" + std::to_string(attributes.location.value()) + + ") exceeds the maximum allowed value of '4095'"); + } + return Success; + }; + + // Check input attributes. + for (auto* param : ep_func->Params()) { + if (auto* str = param->Type()->As()) { + for (auto* member : str->Members()) { + TINT_CHECK_RESULT(check_io_attributes(member->Attributes())); + } + } else { + TINT_CHECK_RESULT(check_io_attributes(param->Attributes())); + } + } + + // Check output attributes. + if (auto* str = ep_func->ReturnType()->As()) { + for (auto* member : str->Members()) { + TINT_CHECK_RESULT(check_io_attributes(member->Attributes())); + } + } else { + TINT_CHECK_RESULT(check_io_attributes(ep_func->ReturnAttributes())); + } + core::ir::ReferencedModuleVars referenced_module_vars{ir}; auto& refs = referenced_module_vars.TransitiveReferences(ep_func); @@ -128,42 +151,6 @@ Result CanGenerate(const core::ir::Module& ir, const Options& optio if (call->Func() == core::BuiltinFn::kPrint) { return Failure("print is not supported by the SPIR-V backend"); } - if (call->Func() == core::BuiltinFn::kHasResource || - call->Func() == core::BuiltinFn::kGetResource) { - if (!options.resource_table) { - return Failure("hasResource and getResource require a resource table"); - } - } - } - - // Check for unsupported shader IO builtins. - auto check_io_attributes = [&](const core::IOAttributes& attributes) -> Result { - if (attributes.builtin == core::BuiltinValue::kGlobalInvocationIndex) { - return Failure( - "@builtin(global_invocation_index) is not supported by the SPIR-V backend"); - } - if (attributes.builtin == core::BuiltinValue::kWorkgroupIndex) { - return Failure("@builtin(workgroup_index) is not supported by the SPIR-V backend"); - } - return Success; - }; - // Check input attributes. - for (auto* param : ep_func->Params()) { - if (auto* str = param->Type()->As()) { - for (auto* member : str->Members()) { - TINT_CHECK_RESULT(check_io_attributes(member->Attributes())); - } - } else { - TINT_CHECK_RESULT(check_io_attributes(param->Attributes())); - } - } - // Check output attributes. - if (auto* str = ep_func->ReturnType()->As()) { - for (auto* member : str->Members()) { - TINT_CHECK_RESULT(check_io_attributes(member->Attributes())); - } - } else { - TINT_CHECK_RESULT(check_io_attributes(ep_func->ReturnAttributes())); } TINT_CHECK_RESULT(ValidateBindingOptions(options)); @@ -171,7 +158,11 @@ Result CanGenerate(const core::ir::Module& ir, const Options& optio return Success; } +} // namespace + Result Generate(core::ir::Module& ir, const Options& options) { + TINT_CHECK_RESULT(CanGenerate(ir, options)); + // There are currently no plans on supporting override-expressions, so we can pull this // information out before the raise. If we want to support overrides then this either needs to // happen in raise, before the builtins are polyfilled, or the analysis needs to also look for diff --git a/3rdparty/dawn/src/tint/lang/spirv/writer/writer.h b/3rdparty/dawn/src/tint/lang/spirv/writer/writer.h index 33c7873ea..23aabd81d 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/writer/writer.h +++ b/3rdparty/dawn/src/tint/lang/spirv/writer/writer.h @@ -35,12 +35,6 @@ namespace tint::spirv::writer { -/// Check if the module @p ir is supported by the SPIR-V backend with @p options. -/// @param ir the module -/// @param options the writer options -/// @returns Success or a failure message indicating why SPIR-V generation would fail -Result CanGenerate(const core::ir::Module& ir, const Options& options); - /// Generate SPIR-V for a program, according to a set of configuration options. /// The result will contain the SPIR-V or failure. /// @param ir the IR module to translate to SPIR-V diff --git a/3rdparty/dawn/src/tint/lang/wgsl/allowed_features.h b/3rdparty/dawn/src/tint/lang/wgsl/allowed_features.h index 4d4ae4bc7..be13ec6e2 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/allowed_features.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/allowed_features.h @@ -31,7 +31,7 @@ #include #include "src/tint/lang/wgsl/enums.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint::wgsl { @@ -41,6 +41,7 @@ struct AllowedFeatures { /// The extensions that are allowed. std::unordered_set extensions; /// The language features that are allowed. + /// Note that this only affects language features that are not fully shipped. std::unordered_set features; /// Helper to produce an AllowedFeatures object that allows all extensions and features. diff --git a/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.cc b/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.cc index b8e977af0..52443a599 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.cc @@ -459,10 +459,6 @@ ast::Type Builder::TypesBuilder::sampler(core::type::SamplerKind kind) const { return sampler(builder->source_, kind); } -ast::Type Builder::TypesBuilder::sampler(core::SamplerFiltering filtering) const { - return sampler(builder->source_, filtering); -} - ast::Type Builder::TypesBuilder::sampler(const Source& source, core::type::SamplerKind kind) const { switch (kind) { case core::type::SamplerKind::kSampler: @@ -473,14 +469,6 @@ ast::Type Builder::TypesBuilder::sampler(const Source& source, core::type::Sampl TINT_ICE() << "invalid sampler kind " << kind; } -ast::Type Builder::TypesBuilder::sampler(const Source& source, - core::SamplerFiltering filtering) const { - TINT_ASSERT(filtering == core::SamplerFiltering::kFiltering || - filtering == core::SamplerFiltering::kNonFiltering); - - return AsType(source, "sampler", filtering); -} - ast::Type Builder::TypesBuilder::depth_texture(core::type::TextureDimension dims) const { return depth_texture(builder->source_, dims); } @@ -543,51 +531,6 @@ ast::Type Builder::TypesBuilder::sampled_texture(const Source& source, TINT_ICE() << "invalid sampled_texture dimensions: " << dims; } -ast::Type Builder::TypesBuilder::sampled_texture(core::type::TextureDimension dims, - ast::Type subtype, - core::TextureFilterable filterable) const { - return sampled_texture(builder->source_, dims, subtype, filterable); -} - -ast::Type Builder::TypesBuilder::sampled_texture(const Source& source, - core::type::TextureDimension dims, - ast::Type subtype, - core::TextureFilterable filterable) const { - TINT_ASSERT(filterable == core::TextureFilterable::kFilterable || - filterable == core::TextureFilterable::kUnfilterable); - - std::string_view name; - switch (dims) { - case core::type::TextureDimension::k1d: - name = "texture_1d"; - break; - case core::type::TextureDimension::k2d: - name = "texture_2d"; - break; - case core::type::TextureDimension::k3d: - name = "texture_3d"; - break; - case core::type::TextureDimension::k2dArray: - name = "texture_2d_array"; - break; - case core::type::TextureDimension::kCube: - name = "texture_cube"; - break; - case core::type::TextureDimension::kCubeArray: - name = "texture_cube_array"; - break; - default: - TINT_ICE() << "invalid sampled_texture dimensions: " << dims; - } - - return ast::Type{builder->Expr( - builder->create(source, builder->Sym(name), - Vector{ - subtype.expr, - builder->Expr(builder->Ident(filterable)), - }))}; -} - ast::Type Builder::TypesBuilder::multisampled_texture(core::type::TextureDimension dims, ast::Type subtype) const { return multisampled_texture(builder->source_, dims, subtype); @@ -688,6 +631,7 @@ ast::Type Builder::TypesBuilder::subgroup_matrix(core::SubgroupMatrixKind kind, case core::SubgroupMatrixKind::kUndefined: TINT_UNREACHABLE(); } + TINT_UNREACHABLE(); } ast::Type Builder::TypesBuilder::buffer(uint32_t size) const { diff --git a/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.h b/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.h index e68ae178d..f9024b51e 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/ast/builder.h @@ -322,11 +322,8 @@ class Builder { /// @param args the remaining arguments to pass to the constructor /// @returns the node pointer template - std::enable_if_t && - !traits::IsTypeOrDerived, - T>* - create(ARG0&& arg0, ARGS&&... args) { + requires(traits::IsTypeOrDerived && !traits::IsTypeOrDerived) + T* create(ARG0&& arg0, ARGS&&... args) { AssertNotMoved(); return ast_nodes_.Create(AllocateNodeID(), source_, std::forward(arg0), std::forward(args)...); @@ -1157,20 +1154,11 @@ class Builder { /// @returns the sampler ast::Type sampler(core::type::SamplerKind kind) const; - /// @param filtering the filtering setting - /// @returns the sampler - ast::Type sampler(core::SamplerFiltering filtering) const; - /// @param source the Source of the node /// @param kind the kind of sampler /// @returns the sampler ast::Type sampler(const Source& source, core::type::SamplerKind kind) const; - /// @param source the Source of the node - /// @param filtering the sampler filtering - /// @returns the sampler - ast::Type sampler(const Source& source, core::SamplerFiltering filtering) const; - /// @param dims the dimensionality of the texture /// @returns the depth texture ast::Type depth_texture(core::type::TextureDimension dims) const; @@ -1195,14 +1183,6 @@ class Builder { /// @returns the sampled texture ast::Type sampled_texture(core::type::TextureDimension dims, ast::Type subtype) const; - /// @param dims the dimensionality of the texture - /// @param subtype the texture subtype. - /// @param filterable the filterability - /// @returns the sampled texture - ast::Type sampled_texture(core::type::TextureDimension dims, - ast::Type subtype, - core::TextureFilterable filterable) const; - /// @param source the Source of the node /// @param dims the dimensionality of the texture /// @param subtype the texture subtype. @@ -1211,16 +1191,6 @@ class Builder { core::type::TextureDimension dims, ast::Type subtype) const; - /// @param source the Source of the node - /// @param dims the dimensionality of the texture - /// @param subtype the texture subtype. - /// @param filterable the filterability - /// @returns the sampled texture - ast::Type sampled_texture(const Source& source, - core::type::TextureDimension dims, - ast::Type subtype, - core::TextureFilterable filterable) const; - /// @param dims the dimensionality of the texture /// @param subtype the texture subtype. /// @returns the multisampled texture @@ -1386,7 +1356,8 @@ class Builder { /// @param enumerator the enumerator /// @return a Symbol with the given enum value - template >>> + template + requires(std::is_enum_v>) Symbol Sym(ENUM&& enumerator) { return Sym(tint::ToString(enumerator)); } @@ -1416,7 +1387,8 @@ class Builder { /// @param identifier the identifier symbol /// @param args the templated identifier arguments /// @return an ast::Identifier with the given symbol and template arguments - template > + template + requires(!IsSource>) const ast::Identifier* Ident(IDENTIFIER&& identifier, ARGS&&... args) { return Ident(source_, std::forward(identifier), std::forward(args)...); } @@ -1459,7 +1431,8 @@ class Builder { /// @param name the identifier name /// @return an ast::IdentifierExpression with the given name - template > + template + requires(IsIdentifierLike>) const ast::IdentifierExpression* Expr(NAME&& name) { auto* ident = Ident(source_, name); return create(ident->source, ident); @@ -1468,7 +1441,8 @@ class Builder { /// @param source the source information /// @param name the identifier name /// @return an ast::IdentifierExpression with the given name - template > + template + requires(IsIdentifierLike>) const ast::IdentifierExpression* Expr(const Source& source, NAME&& name) { return create(source, Ident(source, name)); } @@ -1491,9 +1465,8 @@ class Builder { /// @param value the boolean value /// @return a Scalar constructor for the given value template - std::enable_if_t, const ast::BoolLiteralExpression*> Expr( - const Source& source, - BOOL value) { + requires(std::is_same_v) + const ast::BoolLiteralExpression* Expr(const Source& source, BOOL value) { return create(source, value); } @@ -3403,11 +3376,10 @@ class Builder { /// Creates an ast::DiagnosticRuleName /// @param name the diagnostic rule name /// @returns the diagnostic rule name - template - const ast::DiagnosticRuleName* DiagnosticRuleName(NAME&& name) { - static_assert(!traits::IsType, ast::TemplatedIdentifier>, - "it is invalid for a diagnostic rule name to be templated"); - auto* name_ident = Ident(std::forward(name)); + const ast::DiagnosticRuleName* DiagnosticRuleName(const ast::Identifier* name) { + TINT_ASSERT(!name->Is()) + << "it is invalid for a diagnostic rule name to be templated"; + auto* name_ident = Ident(name); return create(name_ident->source, name_ident); } @@ -3415,14 +3387,15 @@ class Builder { /// @param category the diagnostic rule category /// @param name the diagnostic rule name /// @returns the diagnostic rule name - template > - const ast::DiagnosticRuleName* DiagnosticRuleName(CATEGORY&& category, NAME&& name) { - static_assert(!traits::IsType, ast::TemplatedIdentifier>, - "it is invalid for a diagnostic rule name to be templated"); - static_assert(!traits::IsType, ast::TemplatedIdentifier>, - "it is invalid for a diagnostic rule category to be templated"); - auto* category_ident = Ident(std::forward(category)); - auto* name_ident = Ident(std::forward(name)); + const ast::DiagnosticRuleName* DiagnosticRuleName(const ast::Identifier* category, + const ast::Identifier* name) { + TINT_ASSERT(!category->Is()) + << "it is invalid for a diagnostic rule category to be templated"; + TINT_ASSERT(!name->Is()) + << "it is invalid for a diagnostic rule name to be templated"; + + auto* category_ident = Ident(category); + auto* name_ident = Ident(name); Source source = category_ident->source; source.range.end = name_ident->source.range.end; return create(source, category_ident, name_ident); @@ -3432,68 +3405,68 @@ class Builder { /// @param source the source information /// @param name the diagnostic rule name /// @returns the diagnostic rule name - template - const ast::DiagnosticRuleName* DiagnosticRuleName(const Source& source, NAME&& name) { - static_assert(!traits::IsType, ast::TemplatedIdentifier>, - "it is invalid for a diagnostic rule name to be templated"); - auto* name_ident = Ident(std::forward(name)); + const ast::DiagnosticRuleName* DiagnosticRuleName(const Source& source, std::string_view name) { + auto* name_ident = Ident(name); return create(source, name_ident); } + /// Creates an ast::DiagnosticRuleName + /// @param name the diagnostic rule name + /// @returns the diagnostic rule name + const ast::DiagnosticRuleName* DiagnosticRuleName(std::string_view name) { + return DiagnosticRuleName(source_, name); + } + /// Creates an ast::DiagnosticRuleName /// @param source the source information /// @param category the diagnostic rule category /// @param name the diagnostic rule name /// @returns the diagnostic rule name - template const ast::DiagnosticRuleName* DiagnosticRuleName(const Source& source, - CATEGORY&& category, - NAME&& name) { - static_assert(!traits::IsType, ast::TemplatedIdentifier>, - "it is invalid for a diagnostic rule name to be templated"); - static_assert(!traits::IsType, ast::TemplatedIdentifier>, - "it is invalid for a diagnostic rule category to be templated"); - auto* category_ident = Ident(std::forward(category)); - auto* name_ident = Ident(std::forward(name)); + std::string_view category, + std::string_view name) { + auto* category_ident = Ident(category); + auto* name_ident = Ident(name); return create(source, category_ident, name_ident); } + /// Creates an ast::DiagnosticRuleName + /// @param category the diagnostic rule category + /// @param name the diagnostic rule name + /// @returns the diagnostic rule name + const ast::DiagnosticRuleName* DiagnosticRuleName(std::string_view category, + std::string_view name) { + return DiagnosticRuleName(source_, category, name); + } + /// Creates an ast::DiagnosticAttribute /// @param source the source information /// @param severity the diagnostic severity control - /// @param rule_args the arguments used to construct the rule name + /// @param rule the diagnostic rule /// @returns the diagnostic attribute pointer - template const ast::DiagnosticAttribute* DiagnosticAttribute(const Source& source, wgsl::DiagnosticSeverity severity, - RULE_ARGS&&... rule_args) { - return create( - source, ast::DiagnosticControl( - severity, DiagnosticRuleName(std::forward(rule_args)...))); + const ast::DiagnosticRuleName* rule) { + return create(source, ast::DiagnosticControl(severity, rule)); } /// Creates an ast::DiagnosticAttribute /// @param severity the diagnostic severity control - /// @param rule_args the arguments used to construct the rule name + /// @param rule the diagnostic rule /// @returns the diagnostic attribute pointer - template const ast::DiagnosticAttribute* DiagnosticAttribute(wgsl::DiagnosticSeverity severity, - RULE_ARGS&&... rule_args) { - return create( - source_, ast::DiagnosticControl( - severity, DiagnosticRuleName(std::forward(rule_args)...))); + const ast::DiagnosticRuleName* rule) { + return DiagnosticAttribute(source_, severity, rule); } /// Add a diagnostic directive to the module. /// @param source the source information /// @param severity the diagnostic severity control - /// @param rule_args the arguments used to construct the rule name + /// @param rule the diagnostic rule /// @returns the diagnostic directive pointer - template const ast::DiagnosticDirective* DiagnosticDirective(const Source& source, wgsl::DiagnosticSeverity severity, - RULE_ARGS&&... rule_args) { - auto* rule = DiagnosticRuleName(std::forward(rule_args)...); + const ast::DiagnosticRuleName* rule) { auto* directive = create(source, ast::DiagnosticControl(severity, rule)); AST().AddDiagnosticDirective(directive); @@ -3502,16 +3475,11 @@ class Builder { /// Add a diagnostic directive to the module. /// @param severity the diagnostic severity control - /// @param rule_args the arguments used to construct the rule name + /// @param rule the diagnostic rule /// @returns the diagnostic directive pointer - template const ast::DiagnosticDirective* DiagnosticDirective(wgsl::DiagnosticSeverity severity, - RULE_ARGS&&... rule_args) { - auto* rule = DiagnosticRuleName(std::forward(rule_args)...); - auto* directive = - create(source_, ast::DiagnosticControl(severity, rule)); - AST().AddDiagnosticDirective(directive); - return directive; + const ast::DiagnosticRuleName* rule) { + return DiagnosticDirective(source_, severity, rule); } /// Sets the current builder source to `src` @@ -3549,8 +3517,8 @@ class Builder { /// by the Resolver. /// @param args a mix of ast::Expression, ast::Statement, ast::Variables. /// @returns the function - template ::value && ...)>> + template + requires(CanWrapInStatement::value && ...) const ast::Function* WrapInFunction(ARGS&&... args) { Vector stmts{ WrapInStatement(std::forward(args))..., diff --git a/3rdparty/dawn/src/tint/lang/wgsl/ast/increment_decrement_statement.h b/3rdparty/dawn/src/tint/lang/wgsl/ast/increment_decrement_statement.h index 030753a30..b9358ae1a 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/ast/increment_decrement_statement.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/ast/increment_decrement_statement.h @@ -50,7 +50,7 @@ class IncrementDecrementStatement final : public Castable clip_distances_size; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/inspector/inspector.cc b/3rdparty/dawn/src/tint/lang/wgsl/inspector/inspector.cc index abd9457aa..dc0decf33 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/inspector/inspector.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/inspector/inspector.cc @@ -31,6 +31,7 @@ #include #include +#include "src/tint/api/common/resource_type.h" #include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/fluent_types.h" #include "src/tint/lang/core/type/array.h" @@ -118,7 +119,8 @@ std::tuple CalculateComponentAndComposition( return {componentType, compositionType}; } -ResourceBinding ConvertBufferToResourceBinding(const tint::sem::GlobalVariable* buffer) { +ResourceBinding ConvertBufferToResourceBinding(const tint::sem::GlobalVariable* buffer, + std::optional buffer_size = std::nullopt) { ResourceBinding result; result.bind_group = buffer->Attributes().binding_point->group; result.binding = buffer->Attributes().binding_point->binding; @@ -126,6 +128,9 @@ ResourceBinding ConvertBufferToResourceBinding(const tint::sem::GlobalVariable* auto* unwrapped_type = buffer->Type()->UnwrapRef(); result.size = unwrapped_type->Size(); + if (buffer_size) { + result.size = static_cast(buffer_size.value()); + } result.size_no_padding = result.size; if (auto* str = unwrapped_type->As()) { result.size_no_padding = str->SizeNoPadding(); @@ -175,7 +180,14 @@ ResourceBinding ConvertHandleToResourceBinding(const tint::sem::GlobalVariable* [&](const core::type::MultisampledTexture* tex) { result.resource_type = ResourceBinding::ResourceType::kMultisampledTexture; result.dim = TypeTextureDimensionToResourceBindingTextureDimension(tex->Dim()); - result.sampled_kind = BaseTypeToSampledKind(tex->Type()); + + auto kind = BaseTypeToSampledKind(tex->Type()); + // The base `f32` type will be `Float` but for a multisampled it is always + // an unfilterable. + if (kind == ResourceBinding::SampledKind::kFloat) { + kind = ResourceBinding::SampledKind::kUnfilterable; + } + result.sampled_kind = kind; }, [&](const core::type::DepthTexture* tex) { result.resource_type = ResourceBinding::ResourceType::kDepthTexture; @@ -350,6 +362,12 @@ EntryPoint Inspector::GetEntryPoint(const tint::ast::Function* func) { core::BuiltinValue::kSampleMask, param->Type(), param->Declaration()->attributes); entry_point.num_workgroups_used |= ContainsBuiltin( core::BuiltinValue::kNumWorkgroups, param->Type(), param->Declaration()->attributes); + // global_invocation_index and workgroup_index are polyfilled using num_workgroups + entry_point.num_workgroups_used |= ContainsBuiltin( + core::BuiltinValue::kWorkgroupIndex, param->Type(), param->Declaration()->attributes); + entry_point.num_workgroups_used |= + ContainsBuiltin(core::BuiltinValue::kGlobalInvocationIndex, param->Type(), + param->Declaration()->attributes); entry_point.vertex_index_used |= ContainsBuiltin( core::BuiltinValue::kVertexIndex, param->Type(), param->Declaration()->attributes); entry_point.instance_index_used |= ContainsBuiltin( @@ -361,6 +379,11 @@ EntryPoint Inspector::GetEntryPoint(const tint::ast::Function* func) { param->Declaration()->attributes); entry_point.subgroup_size_used |= ContainsBuiltin( core::BuiltinValue::kSubgroupSize, param->Type(), param->Declaration()->attributes); + entry_point.global_invocation_index_used |= + ContainsBuiltin(core::BuiltinValue::kGlobalInvocationIndex, param->Type(), + param->Declaration()->attributes); + entry_point.workgroup_index_used |= ContainsBuiltin( + core::BuiltinValue::kWorkgroupIndex, param->Type(), param->Declaration()->attributes); if (entry_point.stage == PipelineStage::kFragment) { entry_point.frag_position_used = ContainsBuiltin( @@ -454,9 +477,11 @@ std::vector Inspector::GetResourceBindings(const std::string& e continue; case core::AddressSpace::kUniform: - case core::AddressSpace::kStorage: - result.push_back(ConvertBufferToResourceBinding(global)); + case core::AddressSpace::kStorage: { + auto size = func_sem->TransitivelyReferencedUnsizedBufferSize(global); + result.push_back(ConvertBufferToResourceBinding(global, size)); break; + } case core::AddressSpace::kHandle: result.push_back(ConvertHandleToResourceBinding(global)); break; @@ -620,6 +645,7 @@ const Inspector::EntryPointTextureMetadata& Inspector::ComputeTextureMetadata( } bool uses_num_levels = false; + bool uses_num_samples = false; switch (builtin->Fn()) { case wgsl::BuiltinFn::kTextureNumLevels: uses_num_levels = true; @@ -637,6 +663,8 @@ const Inspector::EntryPointTextureMetadata& Inspector::ComputeTextureMetadata( uses_num_levels = !texture_type->IsAnyOf(); + uses_num_samples = texture_type->IsAnyOf(); metadata.has_texture_load_with_depth_texture |= texture_type ->IsAnyOf(); @@ -651,10 +679,7 @@ const Inspector::EntryPointTextureMetadata& Inspector::ComputeTextureMetadata( break; case wgsl::BuiltinFn::kTextureNumSamples: - for (const auto* texture : textures) { - auto texture_binding_point = texture->Attributes().binding_point.value(); - metadata.textures_with_num_samples.insert(texture_binding_point); - } + uses_num_samples = true; break; default: @@ -667,6 +692,12 @@ const Inspector::EntryPointTextureMetadata& Inspector::ComputeTextureMetadata( metadata.textures_with_num_levels.insert(texture_binding_point); } } + if (uses_num_samples) { + for (const auto* texture : textures) { + auto texture_binding_point = texture->Attributes().binding_point.value(); + metadata.textures_with_num_samples.insert(texture_binding_point); + } + } }; // Iterate the call graph in reverse topological order such that function callers come before diff --git a/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.cc b/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.cc index b9888add8..1653bb6f5 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.cc @@ -61,14 +61,6 @@ ResourceBinding::TextureDimension TypeTextureDimensionToResourceBindingTextureDi } ResourceBinding::SampledKind ToFilterableSampledKind(const core::type::SampledTexture* tex) { - switch (tex->Filterable()) { - case core::TextureFilterable::kFilterable: - return ResourceBinding::SampledKind::kFilterable; - case core::TextureFilterable::kUnfilterable: - return ResourceBinding::SampledKind::kUnfilterable; - default: - break; - } // We don't want to say `float` in this case, we want `unknown-filterable` to signify the // unknown filterablity. if (tex->Type()->Is()) { @@ -95,14 +87,7 @@ ResourceBinding::SampledKind BaseTypeToSampledKind(const core::type::Type* base_ ResourceBinding::SamplerType SamplerToSamplerType(const core::type::Sampler* sampler) { if (sampler->Kind() == core::type::SamplerKind::kSampler) { - switch (sampler->Filtering()) { - case core::SamplerFiltering::kFiltering: - return ResourceBinding::SamplerType::kFiltering; - case core::SamplerFiltering::kNonFiltering: - return ResourceBinding::SamplerType::kNonFiltering; - default: - return ResourceBinding::SamplerType::kUnknownFiltering; - } + return ResourceBinding::SamplerType::kUnknownFiltering; } if (sampler->Kind() == core::type::SamplerKind::kComparisonSampler) { return ResourceBinding::SamplerType::kComparison; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.h b/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.h index 607c9174e..a1390fd40 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding.h @@ -145,30 +145,30 @@ struct ResourceBinding { }; /// Type of resource that is bound. - ResourceType resource_type; + ResourceType resource_type = ResourceType::kUniformBuffer; /// Bind group the binding belongs - uint32_t bind_group; + uint32_t bind_group = 0; /// Identifier to identify this binding within the bind group - uint32_t binding; + uint32_t binding = 0; /// Input attachment index. Only available for input attachments. - uint32_t input_attachment_index; + uint32_t input_attachment_index = 0; /// Size for this binding, in bytes, if defined. - uint64_t size; + uint64_t size = 0; /// The array_size, if the binding is in a binding_array - std::optional array_size; + std::optional array_size = std::nullopt; /// Size for this binding without trailing structure padding, in bytes, if /// defined. - uint64_t size_no_padding; + uint64_t size_no_padding = 0; /// Dimensionality of this binding, if defined. - TextureDimension dim; + TextureDimension dim = TextureDimension::kNone; /// Kind of data being sampled, if defined. - SampledKind sampled_kind; + SampledKind sampled_kind = SampledKind::kFloat; /// Sampler information, if defined - SamplerType sampler_type; + SamplerType sampler_type = SamplerType::kFiltering; /// Format of data, if defined. - TexelFormat image_format; + TexelFormat image_format = TexelFormat::kNone; /// Variable name of the binding. - std::string variable_name; + std::string variable_name = ""; }; /// Convert from internal core::type::TextureDimension to public diff --git a/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding_info.h b/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding_info.h index 9b99aa405..c3ae16035 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding_info.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/inspector/resource_binding_info.h @@ -39,9 +39,9 @@ namespace tint::inspector { /// Container for information about how a resource is bound struct ResourceBindingInfo { /// Bind group the binding belongs - uint32_t group; + uint32_t group = 0; /// Identifier to identify this binding within the bind group - uint32_t binding; + uint32_t binding = 0; /// The types used with the binding array std::vector type_info{}; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/intrinsic/data.cc b/3rdparty/dawn/src/tint/lang/wgsl/intrinsic/data.cc index adcd3ca32..d66675008 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/intrinsic/data.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/intrinsic/data.cc @@ -704,26 +704,6 @@ constexpr TypeMatcher kSamplerComparisonMatcher { }; -/// TypeMatcher for 'type sampler_filtered' -constexpr TypeMatcher kSamplerFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - Number F = Number::invalid; - if (!MatchSamplerFiltered(state, ty, F)) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildSamplerFiltered(state, ty, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText F; - state->PrintNum(F); - out << style::Type("sampler<", F, ">"); - } -}; - - /// TypeMatcher for 'type texture_1d' constexpr TypeMatcher kTexture1DMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -844,162 +824,6 @@ constexpr TypeMatcher kTextureCubeArrayMatcher { }; -/// TypeMatcher for 'type texture_1d_filtered' -constexpr TypeMatcher kTexture1DFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture1DFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture1DFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_1d"); - } -}; - - -/// TypeMatcher for 'type texture_2d_filtered' -constexpr TypeMatcher kTexture2DFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture2DFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture2DFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_2d"); - } -}; - - -/// TypeMatcher for 'type texture_2d_array_filtered' -constexpr TypeMatcher kTexture2DArrayFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture2DArrayFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture2DArrayFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_2d_array"); - } -}; - - -/// TypeMatcher for 'type texture_3d_filtered' -constexpr TypeMatcher kTexture3DFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTexture3DFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTexture3DFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_3d"); - } -}; - - -/// TypeMatcher for 'type texture_cube_filtered' -constexpr TypeMatcher kTextureCubeFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTextureCubeFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTextureCubeFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_cube"); - } -}; - - -/// TypeMatcher for 'type texture_cube_array_filtered' -constexpr TypeMatcher kTextureCubeArrayFilteredMatcher { -/* match */ [](MatchState& state, const Type* ty) -> const Type* { - const Type* T = nullptr; - Number F = Number::invalid; - if (!MatchTextureCubeArrayFiltered(state, ty, T, F)) { - return nullptr; - } - T = state.Type(T); - if (T == nullptr) { - return nullptr; - } - F = state.Num(F); - if (!F.IsValid()) { - return nullptr; - } - return BuildTextureCubeArrayFiltered(state, ty, T, F); - }, -/* print */ []([[maybe_unused]] MatchState* state, StyledText& out) {StyledText T; - state->PrintType(T);StyledText F; - state->PrintNum(F); - out << style::Type("texture_cube_array"); - } -}; - - /// TypeMatcher for 'type texture_multisampled_2d' constexpr TypeMatcher kTextureMultisampled2DMatcher { /* match */ [](MatchState& state, const Type* ty) -> const Type* { @@ -1993,90 +1817,6 @@ constexpr TypeMatcher kSubgroupMatrixElementsMatcher { kF32Matcher.print(nullptr, out); out << style::Plain(", "); kF16Matcher.print(nullptr, out); out << style::Plain(", "); kU32Matcher.print(nullptr, out); out << style::Plain(", "); kI32Matcher.print(nullptr, out); out << style::Plain(", "); kU8Matcher.print(nullptr, out); out << style::Plain(" or "); kI8Matcher.print(nullptr, out);} }; -/// EnumMatcher for 'match filterable' -constexpr NumberMatcher kFilterableMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::TextureFilterable::kFilterable)) { - return Number(static_cast(core::TextureFilterable::kFilterable)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filterable"); - } -}; - -/// EnumMatcher for 'match unfilterable' -constexpr NumberMatcher kUnfilterableMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::TextureFilterable::kUnfilterable)) { - return Number(static_cast(core::TextureFilterable::kUnfilterable)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("unfilterable"); - } -}; - -/// EnumMatcher for 'match filtering' -constexpr NumberMatcher kFilteringMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::SamplerFiltering::kFiltering)) { - return Number(static_cast(core::SamplerFiltering::kFiltering)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filtering"); - } -}; - -/// EnumMatcher for 'match non_filtering' -constexpr NumberMatcher kNonFilteringMatcher { -/* match */ [](MatchState&, Number number) -> Number { - if (number.IsAny() || number.Value() == static_cast(core::SamplerFiltering::kNonFiltering)) { - return Number(static_cast(core::SamplerFiltering::kNonFiltering)); - } - return Number::invalid; - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("non_filtering"); - } -}; - -/// EnumMatcher for 'match texture_filter' -constexpr NumberMatcher kTextureFilterMatcher { -/* match */ [](MatchState&, Number number) -> Number { - switch (static_cast(number.Value())) { - case core::TextureFilterable::kFilterable: - case core::TextureFilterable::kUnfilterable: - return number; - default: - return Number::invalid; - } - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filterable")<< style::Plain(" or ") << style::Enum("unfilterable"); - } -}; - -/// EnumMatcher for 'match sampler_filter' -constexpr NumberMatcher kSamplerFilterMatcher { -/* match */ [](MatchState&, Number number) -> Number { - switch (static_cast(number.Value())) { - case core::SamplerFiltering::kFiltering: - case core::SamplerFiltering::kNonFiltering: - return number; - default: - return Number::invalid; - } - }, -/* print */ [](MatchState*, StyledText& out) { - out<< style::Enum("filtering")<< style::Plain(" or ") << style::Enum("non_filtering"); - } -}; - /// EnumMatcher for 'match subgroup_matrix_kind_left' constexpr NumberMatcher kSubgroupMatrixKindLeftMatcher { /* match */ [](MatchState&, Number number) -> Number { @@ -2354,95 +2094,91 @@ constexpr TypeMatcher kTypeMatchers[] = { /* [3] */ TemplateTypeMatcher<3>::matcher, /* [4] */ TemplateTypeMatcher<4>::matcher, /* [5] */ TemplateTypeMatcher<5>::matcher, - /* [6] */ kBoolMatcher, - /* [7] */ kI8Matcher, - /* [8] */ kU8Matcher, - /* [9] */ kIaMatcher, - /* [10] */ kFaMatcher, - /* [11] */ kI32Matcher, - /* [12] */ kU32Matcher, - /* [13] */ kF32Matcher, - /* [14] */ kF16Matcher, - /* [15] */ kVec2Matcher, - /* [16] */ kVec3Matcher, - /* [17] */ kVec4Matcher, - /* [18] */ kMat2X2Matcher, - /* [19] */ kMat2X3Matcher, - /* [20] */ kMat2X4Matcher, - /* [21] */ kMat3X2Matcher, - /* [22] */ kMat3X3Matcher, - /* [23] */ kMat3X4Matcher, - /* [24] */ kMat4X2Matcher, - /* [25] */ kMat4X3Matcher, - /* [26] */ kMat4X4Matcher, - /* [27] */ kVecMatcher, - /* [28] */ kMatMatcher, - /* [29] */ kPtrMatcher, - /* [30] */ kRefMatcher, - /* [31] */ kAtomicMatcher, - /* [32] */ kRuntimeArrayMatcher, - /* [33] */ kArrayMatcher, - /* [34] */ kBindingArrayMatcher, - /* [35] */ kSamplerMatcher, - /* [36] */ kSamplerComparisonMatcher, - /* [37] */ kSamplerFilteredMatcher, - /* [38] */ kTexture1DMatcher, - /* [39] */ kTexture2DMatcher, - /* [40] */ kTexture2DArrayMatcher, - /* [41] */ kTexture3DMatcher, - /* [42] */ kTextureCubeMatcher, - /* [43] */ kTextureCubeArrayMatcher, - /* [44] */ kTexture1DFilteredMatcher, - /* [45] */ kTexture2DFilteredMatcher, - /* [46] */ kTexture2DArrayFilteredMatcher, - /* [47] */ kTexture3DFilteredMatcher, - /* [48] */ kTextureCubeFilteredMatcher, - /* [49] */ kTextureCubeArrayFilteredMatcher, - /* [50] */ kTextureMultisampled2DMatcher, - /* [51] */ kTextureDepth2DMatcher, - /* [52] */ kTextureDepth2DArrayMatcher, - /* [53] */ kTextureDepthCubeMatcher, - /* [54] */ kTextureDepthCubeArrayMatcher, - /* [55] */ kTextureDepthMultisampled2DMatcher, - /* [56] */ kTextureStorage1DMatcher, - /* [57] */ kTextureStorage2DMatcher, - /* [58] */ kTextureStorage2DArrayMatcher, - /* [59] */ kTextureStorage3DMatcher, - /* [60] */ kTextureExternalMatcher, - /* [61] */ kTexelBufferMatcher, - /* [62] */ kInputAttachmentMatcher, - /* [63] */ kModfResultMatcher, - /* [64] */ kModfResultVecMatcher, - /* [65] */ kFrexpResultMatcher, - /* [66] */ kFrexpResultVecMatcher, - /* [67] */ kAtomicCompareExchangeResultMatcher, - /* [68] */ kSubgroupMatrixMatcher, - /* [69] */ kUnsizedBufferMatcher, - /* [70] */ kBufferMatcher, - /* [71] */ kConstructibleMatcher, - /* [72] */ kScalarMatcher, - /* [73] */ kConcreteScalarMatcher, - /* [74] */ kScalarNoF32Matcher, - /* [75] */ kScalarNoF16Matcher, - /* [76] */ kScalarNoI32Matcher, - /* [77] */ kScalarNoU32Matcher, - /* [78] */ kScalarNoBoolMatcher, - /* [79] */ kFiaFiu32F16Matcher, - /* [80] */ kFiaFi32F16Matcher, - /* [81] */ kFiaFiu32Matcher, - /* [82] */ kFaF32Matcher, - /* [83] */ kFaF32F16Matcher, - /* [84] */ kIaIu32Matcher, - /* [85] */ kIaI32Matcher, - /* [86] */ kFiu32F16Matcher, - /* [87] */ kFiu32Matcher, - /* [88] */ kFi32F16Matcher, - /* [89] */ kFi32Matcher, - /* [90] */ kF32F16Matcher, - /* [91] */ kIu32Matcher, - /* [92] */ kIu32Iu8Matcher, - /* [93] */ kIu8Matcher, - /* [94] */ kSubgroupMatrixElementsMatcher, + /* [6] */ TemplateTypeMatcher<6>::matcher, + /* [7] */ TemplateTypeMatcher<7>::matcher, + /* [8] */ TemplateTypeMatcher<8>::matcher, + /* [9] */ kBoolMatcher, + /* [10] */ kI8Matcher, + /* [11] */ kU8Matcher, + /* [12] */ kIaMatcher, + /* [13] */ kFaMatcher, + /* [14] */ kI32Matcher, + /* [15] */ kU32Matcher, + /* [16] */ kF32Matcher, + /* [17] */ kF16Matcher, + /* [18] */ kVec2Matcher, + /* [19] */ kVec3Matcher, + /* [20] */ kVec4Matcher, + /* [21] */ kMat2X2Matcher, + /* [22] */ kMat2X3Matcher, + /* [23] */ kMat2X4Matcher, + /* [24] */ kMat3X2Matcher, + /* [25] */ kMat3X3Matcher, + /* [26] */ kMat3X4Matcher, + /* [27] */ kMat4X2Matcher, + /* [28] */ kMat4X3Matcher, + /* [29] */ kMat4X4Matcher, + /* [30] */ kVecMatcher, + /* [31] */ kMatMatcher, + /* [32] */ kPtrMatcher, + /* [33] */ kRefMatcher, + /* [34] */ kAtomicMatcher, + /* [35] */ kRuntimeArrayMatcher, + /* [36] */ kArrayMatcher, + /* [37] */ kBindingArrayMatcher, + /* [38] */ kSamplerMatcher, + /* [39] */ kSamplerComparisonMatcher, + /* [40] */ kTexture1DMatcher, + /* [41] */ kTexture2DMatcher, + /* [42] */ kTexture2DArrayMatcher, + /* [43] */ kTexture3DMatcher, + /* [44] */ kTextureCubeMatcher, + /* [45] */ kTextureCubeArrayMatcher, + /* [46] */ kTextureMultisampled2DMatcher, + /* [47] */ kTextureDepth2DMatcher, + /* [48] */ kTextureDepth2DArrayMatcher, + /* [49] */ kTextureDepthCubeMatcher, + /* [50] */ kTextureDepthCubeArrayMatcher, + /* [51] */ kTextureDepthMultisampled2DMatcher, + /* [52] */ kTextureStorage1DMatcher, + /* [53] */ kTextureStorage2DMatcher, + /* [54] */ kTextureStorage2DArrayMatcher, + /* [55] */ kTextureStorage3DMatcher, + /* [56] */ kTextureExternalMatcher, + /* [57] */ kTexelBufferMatcher, + /* [58] */ kInputAttachmentMatcher, + /* [59] */ kModfResultMatcher, + /* [60] */ kModfResultVecMatcher, + /* [61] */ kFrexpResultMatcher, + /* [62] */ kFrexpResultVecMatcher, + /* [63] */ kAtomicCompareExchangeResultMatcher, + /* [64] */ kSubgroupMatrixMatcher, + /* [65] */ kUnsizedBufferMatcher, + /* [66] */ kBufferMatcher, + /* [67] */ kConstructibleMatcher, + /* [68] */ kScalarMatcher, + /* [69] */ kConcreteScalarMatcher, + /* [70] */ kScalarNoF32Matcher, + /* [71] */ kScalarNoF16Matcher, + /* [72] */ kScalarNoI32Matcher, + /* [73] */ kScalarNoU32Matcher, + /* [74] */ kScalarNoBoolMatcher, + /* [75] */ kFiaFiu32F16Matcher, + /* [76] */ kFiaFi32F16Matcher, + /* [77] */ kFiaFiu32Matcher, + /* [78] */ kFaF32Matcher, + /* [79] */ kFaF32F16Matcher, + /* [80] */ kIaIu32Matcher, + /* [81] */ kIaI32Matcher, + /* [82] */ kFiu32F16Matcher, + /* [83] */ kFiu32Matcher, + /* [84] */ kFi32F16Matcher, + /* [85] */ kFi32Matcher, + /* [86] */ kF32F16Matcher, + /* [87] */ kIu32Matcher, + /* [88] */ kIu32Iu8Matcher, + /* [89] */ kIu8Matcher, + /* [90] */ kSubgroupMatrixElementsMatcher, }; /// The template numbers, and number matchers @@ -2453,593 +2189,514 @@ constexpr NumberMatcher kNumberMatchers[] = { /* [3] */ TemplateNumberMatcher<3>::matcher, /* [4] */ TemplateNumberMatcher<4>::matcher, /* [5] */ TemplateNumberMatcher<5>::matcher, - /* [6] */ kFilterableMatcher, - /* [7] */ kUnfilterableMatcher, - /* [8] */ kFilteringMatcher, - /* [9] */ kNonFilteringMatcher, - /* [10] */ kTextureFilterMatcher, - /* [11] */ kSamplerFilterMatcher, - /* [12] */ kSubgroupMatrixKindLeftMatcher, - /* [13] */ kSubgroupMatrixKindRightMatcher, - /* [14] */ kSubgroupMatrixKindResultMatcher, - /* [15] */ kF32TexelFormatMatcher, - /* [16] */ kI32TexelFormatMatcher, - /* [17] */ kU32TexelFormatMatcher, - /* [18] */ kReadMatcher, - /* [19] */ kWriteMatcher, - /* [20] */ kReadWriteMatcher, - /* [21] */ kReadableMatcher, - /* [22] */ kWritableMatcher, - /* [23] */ kFunctionPrivateWorkgroupMatcher, - /* [24] */ kWorkgroupOrStorageMatcher, - /* [25] */ kStorageMatcher, - /* [26] */ kWorkgroupMatcher, - /* [27] */ kUniformOrStorageMatcher, + /* [6] */ TemplateNumberMatcher<6>::matcher, + /* [7] */ TemplateNumberMatcher<7>::matcher, + /* [8] */ TemplateNumberMatcher<8>::matcher, + /* [9] */ kSubgroupMatrixKindLeftMatcher, + /* [10] */ kSubgroupMatrixKindRightMatcher, + /* [11] */ kSubgroupMatrixKindResultMatcher, + /* [12] */ kF32TexelFormatMatcher, + /* [13] */ kI32TexelFormatMatcher, + /* [14] */ kU32TexelFormatMatcher, + /* [15] */ kReadMatcher, + /* [16] */ kWriteMatcher, + /* [17] */ kReadWriteMatcher, + /* [18] */ kReadableMatcher, + /* [19] */ kWritableMatcher, + /* [20] */ kFunctionPrivateWorkgroupMatcher, + /* [21] */ kWorkgroupOrStorageMatcher, + /* [22] */ kStorageMatcher, + /* [23] */ kWorkgroupMatcher, + /* [24] */ kUniformOrStorageMatcher, }; constexpr MatcherIndex kMatcherIndices[] = { - /* [0] */ MatcherIndex(29), - /* [1] */ MatcherIndex(25), - /* [2] */ MatcherIndex(31), - /* [3] */ MatcherIndex(15), - /* [4] */ MatcherIndex(12), - /* [5] */ MatcherIndex(20), - /* [6] */ MatcherIndex(0), - /* [7] */ MatcherIndex(29), - /* [8] */ MatcherIndex(24), - /* [9] */ MatcherIndex(33), - /* [10] */ MatcherIndex(2), - /* [11] */ MatcherIndex(5), - /* [12] */ MatcherIndex(21), - /* [13] */ MatcherIndex(0), - /* [14] */ MatcherIndex(29), - /* [15] */ MatcherIndex(24), - /* [16] */ MatcherIndex(33), - /* [17] */ MatcherIndex(11), - /* [18] */ MatcherIndex(5), - /* [19] */ MatcherIndex(21), - /* [20] */ MatcherIndex(13), - /* [21] */ MatcherIndex(29), - /* [22] */ MatcherIndex(24), - /* [23] */ MatcherIndex(33), - /* [24] */ MatcherIndex(12), - /* [25] */ MatcherIndex(5), - /* [26] */ MatcherIndex(21), - /* [27] */ MatcherIndex(14), - /* [28] */ MatcherIndex(29), - /* [29] */ MatcherIndex(24), - /* [30] */ MatcherIndex(33), - /* [31] */ MatcherIndex(1), - /* [32] */ MatcherIndex(4), - /* [33] */ MatcherIndex(22), - /* [34] */ MatcherIndex(0), - /* [35] */ MatcherIndex(29), - /* [36] */ MatcherIndex(24), - /* [37] */ MatcherIndex(33), - /* [38] */ MatcherIndex(11), - /* [39] */ MatcherIndex(4), - /* [40] */ MatcherIndex(22), - /* [41] */ MatcherIndex(13), - /* [42] */ MatcherIndex(29), - /* [43] */ MatcherIndex(24), - /* [44] */ MatcherIndex(33), - /* [45] */ MatcherIndex(12), + /* [0] */ MatcherIndex(32), + /* [1] */ MatcherIndex(22), + /* [2] */ MatcherIndex(34), + /* [3] */ MatcherIndex(18), + /* [4] */ MatcherIndex(15), + /* [5] */ MatcherIndex(17), + /* [6] */ MatcherIndex(32), + /* [7] */ MatcherIndex(6), + /* [8] */ MatcherIndex(36), + /* [9] */ MatcherIndex(2), + /* [10] */ MatcherIndex(5), + /* [11] */ MatcherIndex(7), + /* [12] */ MatcherIndex(32), + /* [13] */ MatcherIndex(6), + /* [14] */ MatcherIndex(36), + /* [15] */ MatcherIndex(14), + /* [16] */ MatcherIndex(5), + /* [17] */ MatcherIndex(7), + /* [18] */ MatcherIndex(32), + /* [19] */ MatcherIndex(6), + /* [20] */ MatcherIndex(36), + /* [21] */ MatcherIndex(15), + /* [22] */ MatcherIndex(5), + /* [23] */ MatcherIndex(7), + /* [24] */ MatcherIndex(32), + /* [25] */ MatcherIndex(7), + /* [26] */ MatcherIndex(36), + /* [27] */ MatcherIndex(3), + /* [28] */ MatcherIndex(6), + /* [29] */ MatcherIndex(8), + /* [30] */ MatcherIndex(32), + /* [31] */ MatcherIndex(7), + /* [32] */ MatcherIndex(36), + /* [33] */ MatcherIndex(14), + /* [34] */ MatcherIndex(6), + /* [35] */ MatcherIndex(8), + /* [36] */ MatcherIndex(32), + /* [37] */ MatcherIndex(7), + /* [38] */ MatcherIndex(36), + /* [39] */ MatcherIndex(15), + /* [40] */ MatcherIndex(6), + /* [41] */ MatcherIndex(8), + /* [42] */ MatcherIndex(32), + /* [43] */ MatcherIndex(5), + /* [44] */ MatcherIndex(36), + /* [45] */ MatcherIndex(1), /* [46] */ MatcherIndex(4), - /* [47] */ MatcherIndex(22), - /* [48] */ MatcherIndex(14), - /* [49] */ MatcherIndex(29), - /* [50] */ MatcherIndex(25), - /* [51] */ MatcherIndex(32), - /* [52] */ MatcherIndex(0), - /* [53] */ MatcherIndex(1), - /* [54] */ MatcherIndex(29), - /* [55] */ MatcherIndex(26), - /* [56] */ MatcherIndex(31), - /* [57] */ MatcherIndex(0), - /* [58] */ MatcherIndex(20), - /* [59] */ MatcherIndex(13), - /* [60] */ MatcherIndex(29), - /* [61] */ MatcherIndex(1), - /* [62] */ MatcherIndex(31), - /* [63] */ MatcherIndex(0), - /* [64] */ MatcherIndex(20), - /* [65] */ MatcherIndex(14), - /* [66] */ MatcherIndex(68), - /* [67] */ MatcherIndex(1), - /* [68] */ MatcherIndex(2), - /* [69] */ MatcherIndex(3), - /* [70] */ MatcherIndex(4), - /* [71] */ MatcherIndex(29), - /* [72] */ MatcherIndex(25), - /* [73] */ MatcherIndex(32), - /* [74] */ MatcherIndex(2), - /* [75] */ MatcherIndex(21), - /* [76] */ MatcherIndex(29), - /* [77] */ MatcherIndex(25), - /* [78] */ MatcherIndex(32), - /* [79] */ MatcherIndex(11), - /* [80] */ MatcherIndex(21), - /* [81] */ MatcherIndex(29), - /* [82] */ MatcherIndex(25), - /* [83] */ MatcherIndex(32), - /* [84] */ MatcherIndex(12), - /* [85] */ MatcherIndex(21), - /* [86] */ MatcherIndex(29), - /* [87] */ MatcherIndex(25), - /* [88] */ MatcherIndex(32), - /* [89] */ MatcherIndex(1), - /* [90] */ MatcherIndex(22), - /* [91] */ MatcherIndex(68), - /* [92] */ MatcherIndex(0), - /* [93] */ MatcherIndex(1), - /* [94] */ MatcherIndex(2), - /* [95] */ MatcherIndex(3), - /* [96] */ MatcherIndex(29), - /* [97] */ MatcherIndex(25), - /* [98] */ MatcherIndex(32), - /* [99] */ MatcherIndex(11), - /* [100] */ MatcherIndex(22), - /* [101] */ MatcherIndex(29), - /* [102] */ MatcherIndex(25), - /* [103] */ MatcherIndex(32), - /* [104] */ MatcherIndex(12), - /* [105] */ MatcherIndex(22), - /* [106] */ MatcherIndex(68), - /* [107] */ MatcherIndex(14), - /* [108] */ MatcherIndex(0), - /* [109] */ MatcherIndex(2), - /* [110] */ MatcherIndex(3), - /* [111] */ MatcherIndex(68), - /* [112] */ MatcherIndex(12), - /* [113] */ MatcherIndex(1), - /* [114] */ MatcherIndex(4), - /* [115] */ MatcherIndex(3), - /* [116] */ MatcherIndex(68), - /* [117] */ MatcherIndex(13), - /* [118] */ MatcherIndex(1), - /* [119] */ MatcherIndex(2), - /* [120] */ MatcherIndex(4), - /* [121] */ MatcherIndex(68), - /* [122] */ MatcherIndex(14), - /* [123] */ MatcherIndex(1), - /* [124] */ MatcherIndex(2), - /* [125] */ MatcherIndex(3), - /* [126] */ MatcherIndex(68), - /* [127] */ MatcherIndex(12), - /* [128] */ MatcherIndex(0), + /* [47] */ MatcherIndex(6), + /* [48] */ MatcherIndex(32), + /* [49] */ MatcherIndex(5), + /* [50] */ MatcherIndex(36), + /* [51] */ MatcherIndex(14), + /* [52] */ MatcherIndex(4), + /* [53] */ MatcherIndex(6), + /* [54] */ MatcherIndex(32), + /* [55] */ MatcherIndex(5), + /* [56] */ MatcherIndex(36), + /* [57] */ MatcherIndex(15), + /* [58] */ MatcherIndex(4), + /* [59] */ MatcherIndex(6), + /* [60] */ MatcherIndex(32), + /* [61] */ MatcherIndex(0), + /* [62] */ MatcherIndex(35), + /* [63] */ MatcherIndex(1), + /* [64] */ MatcherIndex(2), + /* [65] */ MatcherIndex(32), + /* [66] */ MatcherIndex(22), + /* [67] */ MatcherIndex(35), + /* [68] */ MatcherIndex(0), + /* [69] */ MatcherIndex(1), + /* [70] */ MatcherIndex(32), + /* [71] */ MatcherIndex(23), + /* [72] */ MatcherIndex(35), + /* [73] */ MatcherIndex(0), + /* [74] */ MatcherIndex(1), + /* [75] */ MatcherIndex(32), + /* [76] */ MatcherIndex(23), + /* [77] */ MatcherIndex(34), + /* [78] */ MatcherIndex(0), + /* [79] */ MatcherIndex(17), + /* [80] */ MatcherIndex(32), + /* [81] */ MatcherIndex(1), + /* [82] */ MatcherIndex(34), + /* [83] */ MatcherIndex(0), + /* [84] */ MatcherIndex(17), + /* [85] */ MatcherIndex(64), + /* [86] */ MatcherIndex(1), + /* [87] */ MatcherIndex(2), + /* [88] */ MatcherIndex(3), + /* [89] */ MatcherIndex(4), + /* [90] */ MatcherIndex(32), + /* [91] */ MatcherIndex(22), + /* [92] */ MatcherIndex(35), + /* [93] */ MatcherIndex(2), + /* [94] */ MatcherIndex(5), + /* [95] */ MatcherIndex(32), + /* [96] */ MatcherIndex(22), + /* [97] */ MatcherIndex(35), + /* [98] */ MatcherIndex(14), + /* [99] */ MatcherIndex(5), + /* [100] */ MatcherIndex(32), + /* [101] */ MatcherIndex(22), + /* [102] */ MatcherIndex(35), + /* [103] */ MatcherIndex(15), + /* [104] */ MatcherIndex(5), + /* [105] */ MatcherIndex(64), + /* [106] */ MatcherIndex(2), + /* [107] */ MatcherIndex(3), + /* [108] */ MatcherIndex(4), + /* [109] */ MatcherIndex(5), + /* [110] */ MatcherIndex(32), + /* [111] */ MatcherIndex(22), + /* [112] */ MatcherIndex(35), + /* [113] */ MatcherIndex(3), + /* [114] */ MatcherIndex(6), + /* [115] */ MatcherIndex(32), + /* [116] */ MatcherIndex(22), + /* [117] */ MatcherIndex(35), + /* [118] */ MatcherIndex(14), + /* [119] */ MatcherIndex(6), + /* [120] */ MatcherIndex(32), + /* [121] */ MatcherIndex(22), + /* [122] */ MatcherIndex(35), + /* [123] */ MatcherIndex(15), + /* [124] */ MatcherIndex(6), + /* [125] */ MatcherIndex(32), + /* [126] */ MatcherIndex(22), + /* [127] */ MatcherIndex(35), + /* [128] */ MatcherIndex(1), /* [129] */ MatcherIndex(4), - /* [130] */ MatcherIndex(3), - /* [131] */ MatcherIndex(68), - /* [132] */ MatcherIndex(13), - /* [133] */ MatcherIndex(0), - /* [134] */ MatcherIndex(2), - /* [135] */ MatcherIndex(4), - /* [136] */ MatcherIndex(68), - /* [137] */ MatcherIndex(0), - /* [138] */ MatcherIndex(7), - /* [139] */ MatcherIndex(1), - /* [140] */ MatcherIndex(2), - /* [141] */ MatcherIndex(68), - /* [142] */ MatcherIndex(0), - /* [143] */ MatcherIndex(8), - /* [144] */ MatcherIndex(1), - /* [145] */ MatcherIndex(2), - /* [146] */ MatcherIndex(29), - /* [147] */ MatcherIndex(2), - /* [148] */ MatcherIndex(70), + /* [130] */ MatcherIndex(64), + /* [131] */ MatcherIndex(0), + /* [132] */ MatcherIndex(1), + /* [133] */ MatcherIndex(2), + /* [134] */ MatcherIndex(3), + /* [135] */ MatcherIndex(32), + /* [136] */ MatcherIndex(22), + /* [137] */ MatcherIndex(35), + /* [138] */ MatcherIndex(14), + /* [139] */ MatcherIndex(4), + /* [140] */ MatcherIndex(32), + /* [141] */ MatcherIndex(22), + /* [142] */ MatcherIndex(35), + /* [143] */ MatcherIndex(15), + /* [144] */ MatcherIndex(4), + /* [145] */ MatcherIndex(64), + /* [146] */ MatcherIndex(11), + /* [147] */ MatcherIndex(0), + /* [148] */ MatcherIndex(2), /* [149] */ MatcherIndex(3), - /* [150] */ MatcherIndex(1), - /* [151] */ MatcherIndex(29), + /* [150] */ MatcherIndex(64), + /* [151] */ MatcherIndex(9), /* [152] */ MatcherIndex(1), - /* [153] */ MatcherIndex(70), - /* [154] */ MatcherIndex(2), - /* [155] */ MatcherIndex(0), - /* [156] */ MatcherIndex(28), - /* [157] */ MatcherIndex(0), - /* [158] */ MatcherIndex(0), - /* [159] */ MatcherIndex(1), - /* [160] */ MatcherIndex(28), - /* [161] */ MatcherIndex(1), - /* [162] */ MatcherIndex(0), + /* [153] */ MatcherIndex(4), + /* [154] */ MatcherIndex(3), + /* [155] */ MatcherIndex(64), + /* [156] */ MatcherIndex(10), + /* [157] */ MatcherIndex(1), + /* [158] */ MatcherIndex(2), + /* [159] */ MatcherIndex(4), + /* [160] */ MatcherIndex(64), + /* [161] */ MatcherIndex(11), + /* [162] */ MatcherIndex(1), /* [163] */ MatcherIndex(2), - /* [164] */ MatcherIndex(28), - /* [165] */ MatcherIndex(0), - /* [166] */ MatcherIndex(1), - /* [167] */ MatcherIndex(2), - /* [168] */ MatcherIndex(29), - /* [169] */ MatcherIndex(26), - /* [170] */ MatcherIndex(0), - /* [171] */ MatcherIndex(20), - /* [172] */ MatcherIndex(29), + /* [164] */ MatcherIndex(3), + /* [165] */ MatcherIndex(64), + /* [166] */ MatcherIndex(9), + /* [167] */ MatcherIndex(0), + /* [168] */ MatcherIndex(4), + /* [169] */ MatcherIndex(3), + /* [170] */ MatcherIndex(64), + /* [171] */ MatcherIndex(10), + /* [172] */ MatcherIndex(0), /* [173] */ MatcherIndex(2), - /* [174] */ MatcherIndex(0), - /* [175] */ MatcherIndex(1), - /* [176] */ MatcherIndex(29), - /* [177] */ MatcherIndex(2), - /* [178] */ MatcherIndex(69), - /* [179] */ MatcherIndex(1), - /* [180] */ MatcherIndex(29), - /* [181] */ MatcherIndex(1), - /* [182] */ MatcherIndex(69), - /* [183] */ MatcherIndex(0), - /* [184] */ MatcherIndex(29), - /* [185] */ MatcherIndex(0), - /* [186] */ MatcherIndex(1), - /* [187] */ MatcherIndex(2), - /* [188] */ MatcherIndex(30), - /* [189] */ MatcherIndex(0), - /* [190] */ MatcherIndex(1), - /* [191] */ MatcherIndex(2), - /* [192] */ MatcherIndex(28), - /* [193] */ MatcherIndex(1), - /* [194] */ MatcherIndex(2), - /* [195] */ MatcherIndex(0), - /* [196] */ MatcherIndex(28), - /* [197] */ MatcherIndex(2), - /* [198] */ MatcherIndex(3), - /* [199] */ MatcherIndex(0), - /* [200] */ MatcherIndex(28), - /* [201] */ MatcherIndex(1), - /* [202] */ MatcherIndex(3), - /* [203] */ MatcherIndex(0), - /* [204] */ MatcherIndex(28), - /* [205] */ MatcherIndex(2), - /* [206] */ MatcherIndex(1), - /* [207] */ MatcherIndex(0), - /* [208] */ MatcherIndex(27), + /* [174] */ MatcherIndex(4), + /* [175] */ MatcherIndex(64), + /* [176] */ MatcherIndex(0), + /* [177] */ MatcherIndex(10), + /* [178] */ MatcherIndex(1), + /* [179] */ MatcherIndex(2), + /* [180] */ MatcherIndex(64), + /* [181] */ MatcherIndex(0), + /* [182] */ MatcherIndex(11), + /* [183] */ MatcherIndex(1), + /* [184] */ MatcherIndex(2), + /* [185] */ MatcherIndex(32), + /* [186] */ MatcherIndex(2), + /* [187] */ MatcherIndex(66), + /* [188] */ MatcherIndex(3), + /* [189] */ MatcherIndex(1), + /* [190] */ MatcherIndex(32), + /* [191] */ MatcherIndex(1), + /* [192] */ MatcherIndex(66), + /* [193] */ MatcherIndex(2), + /* [194] */ MatcherIndex(0), + /* [195] */ MatcherIndex(31), + /* [196] */ MatcherIndex(0), + /* [197] */ MatcherIndex(0), + /* [198] */ MatcherIndex(1), + /* [199] */ MatcherIndex(31), + /* [200] */ MatcherIndex(1), + /* [201] */ MatcherIndex(0), + /* [202] */ MatcherIndex(2), + /* [203] */ MatcherIndex(31), + /* [204] */ MatcherIndex(0), + /* [205] */ MatcherIndex(1), + /* [206] */ MatcherIndex(2), + /* [207] */ MatcherIndex(32), + /* [208] */ MatcherIndex(23), /* [209] */ MatcherIndex(0), - /* [210] */ MatcherIndex(1), - /* [211] */ MatcherIndex(27), - /* [212] */ MatcherIndex(0), - /* [213] */ MatcherIndex(6), - /* [214] */ MatcherIndex(27), - /* [215] */ MatcherIndex(1), - /* [216] */ MatcherIndex(0), - /* [217] */ MatcherIndex(27), + /* [210] */ MatcherIndex(17), + /* [211] */ MatcherIndex(32), + /* [212] */ MatcherIndex(2), + /* [213] */ MatcherIndex(0), + /* [214] */ MatcherIndex(1), + /* [215] */ MatcherIndex(32), + /* [216] */ MatcherIndex(2), + /* [217] */ MatcherIndex(65), /* [218] */ MatcherIndex(1), - /* [219] */ MatcherIndex(87), - /* [220] */ MatcherIndex(27), - /* [221] */ MatcherIndex(1), - /* [222] */ MatcherIndex(2), - /* [223] */ MatcherIndex(27), - /* [224] */ MatcherIndex(1), - /* [225] */ MatcherIndex(14), - /* [226] */ MatcherIndex(27), - /* [227] */ MatcherIndex(1), - /* [228] */ MatcherIndex(12), - /* [229] */ MatcherIndex(27), - /* [230] */ MatcherIndex(1), - /* [231] */ MatcherIndex(9), - /* [232] */ MatcherIndex(27), - /* [233] */ MatcherIndex(0), - /* [234] */ MatcherIndex(13), - /* [235] */ MatcherIndex(66), - /* [236] */ MatcherIndex(0), - /* [237] */ MatcherIndex(1), - /* [238] */ MatcherIndex(27), - /* [239] */ MatcherIndex(0), - /* [240] */ MatcherIndex(2), - /* [241] */ MatcherIndex(64), + /* [219] */ MatcherIndex(32), + /* [220] */ MatcherIndex(1), + /* [221] */ MatcherIndex(65), + /* [222] */ MatcherIndex(0), + /* [223] */ MatcherIndex(32), + /* [224] */ MatcherIndex(0), + /* [225] */ MatcherIndex(1), + /* [226] */ MatcherIndex(2), + /* [227] */ MatcherIndex(33), + /* [228] */ MatcherIndex(0), + /* [229] */ MatcherIndex(1), + /* [230] */ MatcherIndex(2), + /* [231] */ MatcherIndex(31), + /* [232] */ MatcherIndex(1), + /* [233] */ MatcherIndex(2), + /* [234] */ MatcherIndex(0), + /* [235] */ MatcherIndex(31), + /* [236] */ MatcherIndex(2), + /* [237] */ MatcherIndex(3), + /* [238] */ MatcherIndex(0), + /* [239] */ MatcherIndex(31), + /* [240] */ MatcherIndex(1), + /* [241] */ MatcherIndex(3), /* [242] */ MatcherIndex(0), - /* [243] */ MatcherIndex(1), - /* [244] */ MatcherIndex(44), - /* [245] */ MatcherIndex(13), + /* [243] */ MatcherIndex(31), + /* [244] */ MatcherIndex(2), + /* [245] */ MatcherIndex(1), /* [246] */ MatcherIndex(0), - /* [247] */ MatcherIndex(45), - /* [248] */ MatcherIndex(13), - /* [249] */ MatcherIndex(0), - /* [250] */ MatcherIndex(46), - /* [251] */ MatcherIndex(13), - /* [252] */ MatcherIndex(0), - /* [253] */ MatcherIndex(47), - /* [254] */ MatcherIndex(13), + /* [247] */ MatcherIndex(30), + /* [248] */ MatcherIndex(0), + /* [249] */ MatcherIndex(1), + /* [250] */ MatcherIndex(30), + /* [251] */ MatcherIndex(0), + /* [252] */ MatcherIndex(9), + /* [253] */ MatcherIndex(30), + /* [254] */ MatcherIndex(1), /* [255] */ MatcherIndex(0), - /* [256] */ MatcherIndex(48), - /* [257] */ MatcherIndex(13), - /* [258] */ MatcherIndex(0), - /* [259] */ MatcherIndex(49), - /* [260] */ MatcherIndex(13), - /* [261] */ MatcherIndex(0), - /* [262] */ MatcherIndex(56), - /* [263] */ MatcherIndex(0), - /* [264] */ MatcherIndex(1), - /* [265] */ MatcherIndex(57), - /* [266] */ MatcherIndex(0), - /* [267] */ MatcherIndex(1), - /* [268] */ MatcherIndex(58), - /* [269] */ MatcherIndex(0), - /* [270] */ MatcherIndex(1), - /* [271] */ MatcherIndex(59), + /* [256] */ MatcherIndex(30), + /* [257] */ MatcherIndex(1), + /* [258] */ MatcherIndex(83), + /* [259] */ MatcherIndex(30), + /* [260] */ MatcherIndex(1), + /* [261] */ MatcherIndex(2), + /* [262] */ MatcherIndex(30), + /* [263] */ MatcherIndex(1), + /* [264] */ MatcherIndex(17), + /* [265] */ MatcherIndex(30), + /* [266] */ MatcherIndex(1), + /* [267] */ MatcherIndex(15), + /* [268] */ MatcherIndex(30), + /* [269] */ MatcherIndex(1), + /* [270] */ MatcherIndex(12), + /* [271] */ MatcherIndex(30), /* [272] */ MatcherIndex(0), - /* [273] */ MatcherIndex(1), - /* [274] */ MatcherIndex(61), + /* [273] */ MatcherIndex(16), + /* [274] */ MatcherIndex(62), /* [275] */ MatcherIndex(0), /* [276] */ MatcherIndex(1), - /* [277] */ MatcherIndex(45), + /* [277] */ MatcherIndex(30), /* [278] */ MatcherIndex(0), - /* [279] */ MatcherIndex(1), - /* [280] */ MatcherIndex(45), + /* [279] */ MatcherIndex(2), + /* [280] */ MatcherIndex(60), /* [281] */ MatcherIndex(0), - /* [282] */ MatcherIndex(6), - /* [283] */ MatcherIndex(45), + /* [282] */ MatcherIndex(1), + /* [283] */ MatcherIndex(52), /* [284] */ MatcherIndex(0), - /* [285] */ MatcherIndex(7), - /* [286] */ MatcherIndex(45), + /* [285] */ MatcherIndex(1), + /* [286] */ MatcherIndex(53), /* [287] */ MatcherIndex(0), - /* [288] */ MatcherIndex(2), - /* [289] */ MatcherIndex(46), + /* [288] */ MatcherIndex(1), + /* [289] */ MatcherIndex(54), /* [290] */ MatcherIndex(0), - /* [291] */ MatcherIndex(3), - /* [292] */ MatcherIndex(46), + /* [291] */ MatcherIndex(1), + /* [292] */ MatcherIndex(55), /* [293] */ MatcherIndex(0), - /* [294] */ MatcherIndex(6), - /* [295] */ MatcherIndex(46), + /* [294] */ MatcherIndex(1), + /* [295] */ MatcherIndex(57), /* [296] */ MatcherIndex(0), - /* [297] */ MatcherIndex(7), - /* [298] */ MatcherIndex(48), - /* [299] */ MatcherIndex(0), - /* [300] */ MatcherIndex(1), - /* [301] */ MatcherIndex(48), - /* [302] */ MatcherIndex(0), - /* [303] */ MatcherIndex(6), - /* [304] */ MatcherIndex(48), - /* [305] */ MatcherIndex(0), - /* [306] */ MatcherIndex(7), - /* [307] */ MatcherIndex(49), - /* [308] */ MatcherIndex(0), - /* [309] */ MatcherIndex(3), - /* [310] */ MatcherIndex(49), - /* [311] */ MatcherIndex(0), - /* [312] */ MatcherIndex(6), - /* [313] */ MatcherIndex(49), - /* [314] */ MatcherIndex(0), - /* [315] */ MatcherIndex(7), - /* [316] */ MatcherIndex(44), - /* [317] */ MatcherIndex(13), - /* [318] */ MatcherIndex(6), - /* [319] */ MatcherIndex(44), - /* [320] */ MatcherIndex(13), - /* [321] */ MatcherIndex(7), - /* [322] */ MatcherIndex(45), - /* [323] */ MatcherIndex(13), - /* [324] */ MatcherIndex(6), - /* [325] */ MatcherIndex(45), - /* [326] */ MatcherIndex(13), - /* [327] */ MatcherIndex(7), - /* [328] */ MatcherIndex(46), - /* [329] */ MatcherIndex(13), - /* [330] */ MatcherIndex(6), - /* [331] */ MatcherIndex(46), - /* [332] */ MatcherIndex(13), - /* [333] */ MatcherIndex(7), - /* [334] */ MatcherIndex(47), - /* [335] */ MatcherIndex(13), - /* [336] */ MatcherIndex(6), - /* [337] */ MatcherIndex(47), - /* [338] */ MatcherIndex(13), - /* [339] */ MatcherIndex(7), - /* [340] */ MatcherIndex(48), - /* [341] */ MatcherIndex(13), - /* [342] */ MatcherIndex(6), - /* [343] */ MatcherIndex(48), - /* [344] */ MatcherIndex(13), - /* [345] */ MatcherIndex(7), - /* [346] */ MatcherIndex(49), - /* [347] */ MatcherIndex(13), - /* [348] */ MatcherIndex(6), - /* [349] */ MatcherIndex(49), - /* [350] */ MatcherIndex(13), - /* [351] */ MatcherIndex(7), - /* [352] */ MatcherIndex(46), - /* [353] */ MatcherIndex(13), - /* [354] */ MatcherIndex(1), - /* [355] */ MatcherIndex(49), - /* [356] */ MatcherIndex(13), - /* [357] */ MatcherIndex(1), - /* [358] */ MatcherIndex(56), - /* [359] */ MatcherIndex(1), - /* [360] */ MatcherIndex(2), - /* [361] */ MatcherIndex(57), - /* [362] */ MatcherIndex(1), - /* [363] */ MatcherIndex(2), - /* [364] */ MatcherIndex(58), - /* [365] */ MatcherIndex(1), - /* [366] */ MatcherIndex(2), - /* [367] */ MatcherIndex(59), - /* [368] */ MatcherIndex(1), - /* [369] */ MatcherIndex(2), - /* [370] */ MatcherIndex(61), - /* [371] */ MatcherIndex(1), - /* [372] */ MatcherIndex(2), + /* [297] */ MatcherIndex(1), + /* [298] */ MatcherIndex(52), + /* [299] */ MatcherIndex(1), + /* [300] */ MatcherIndex(2), + /* [301] */ MatcherIndex(53), + /* [302] */ MatcherIndex(1), + /* [303] */ MatcherIndex(2), + /* [304] */ MatcherIndex(54), + /* [305] */ MatcherIndex(1), + /* [306] */ MatcherIndex(2), + /* [307] */ MatcherIndex(55), + /* [308] */ MatcherIndex(1), + /* [309] */ MatcherIndex(2), + /* [310] */ MatcherIndex(57), + /* [311] */ MatcherIndex(1), + /* [312] */ MatcherIndex(2), + /* [313] */ MatcherIndex(30), + /* [314] */ MatcherIndex(2), + /* [315] */ MatcherIndex(0), + /* [316] */ MatcherIndex(30), + /* [317] */ MatcherIndex(1), + /* [318] */ MatcherIndex(9), + /* [319] */ MatcherIndex(18), + /* [320] */ MatcherIndex(17), + /* [321] */ MatcherIndex(18), + /* [322] */ MatcherIndex(83), + /* [323] */ MatcherIndex(20), + /* [324] */ MatcherIndex(17), + /* [325] */ MatcherIndex(18), + /* [326] */ MatcherIndex(1), + /* [327] */ MatcherIndex(19), + /* [328] */ MatcherIndex(0), + /* [329] */ MatcherIndex(61), + /* [330] */ MatcherIndex(0), + /* [331] */ MatcherIndex(59), + /* [332] */ MatcherIndex(0), + /* [333] */ MatcherIndex(18), + /* [334] */ MatcherIndex(16), + /* [335] */ MatcherIndex(20), + /* [336] */ MatcherIndex(16), + /* [337] */ MatcherIndex(20), + /* [338] */ MatcherIndex(14), + /* [339] */ MatcherIndex(20), + /* [340] */ MatcherIndex(15), + /* [341] */ MatcherIndex(40), + /* [342] */ MatcherIndex(0), + /* [343] */ MatcherIndex(41), + /* [344] */ MatcherIndex(0), + /* [345] */ MatcherIndex(42), + /* [346] */ MatcherIndex(0), + /* [347] */ MatcherIndex(19), + /* [348] */ MatcherIndex(15), + /* [349] */ MatcherIndex(43), + /* [350] */ MatcherIndex(0), + /* [351] */ MatcherIndex(44), + /* [352] */ MatcherIndex(0), + /* [353] */ MatcherIndex(45), + /* [354] */ MatcherIndex(0), + /* [355] */ MatcherIndex(46), + /* [356] */ MatcherIndex(0), + /* [357] */ MatcherIndex(20), + /* [358] */ MatcherIndex(0), + /* [359] */ MatcherIndex(18), + /* [360] */ MatcherIndex(14), + /* [361] */ MatcherIndex(19), + /* [362] */ MatcherIndex(16), + /* [363] */ MatcherIndex(40), + /* [364] */ MatcherIndex(16), + /* [365] */ MatcherIndex(41), + /* [366] */ MatcherIndex(16), + /* [367] */ MatcherIndex(42), + /* [368] */ MatcherIndex(16), + /* [369] */ MatcherIndex(43), + /* [370] */ MatcherIndex(16), + /* [371] */ MatcherIndex(19), + /* [372] */ MatcherIndex(14), /* [373] */ MatcherIndex(44), - /* [374] */ MatcherIndex(0), - /* [375] */ MatcherIndex(3), - /* [376] */ MatcherIndex(45), - /* [377] */ MatcherIndex(0), - /* [378] */ MatcherIndex(3), - /* [379] */ MatcherIndex(46), - /* [380] */ MatcherIndex(0), - /* [381] */ MatcherIndex(4), - /* [382] */ MatcherIndex(47), - /* [383] */ MatcherIndex(0), - /* [384] */ MatcherIndex(3), - /* [385] */ MatcherIndex(44), - /* [386] */ MatcherIndex(13), - /* [387] */ MatcherIndex(1), - /* [388] */ MatcherIndex(45), - /* [389] */ MatcherIndex(13), + /* [374] */ MatcherIndex(16), + /* [375] */ MatcherIndex(45), + /* [376] */ MatcherIndex(16), + /* [377] */ MatcherIndex(18), + /* [378] */ MatcherIndex(0), + /* [379] */ MatcherIndex(19), + /* [380] */ MatcherIndex(1), + /* [381] */ MatcherIndex(58), + /* [382] */ MatcherIndex(0), + /* [383] */ MatcherIndex(63), + /* [384] */ MatcherIndex(0), + /* [385] */ MatcherIndex(40), + /* [386] */ MatcherIndex(1), + /* [387] */ MatcherIndex(41), + /* [388] */ MatcherIndex(1), + /* [389] */ MatcherIndex(42), /* [390] */ MatcherIndex(1), - /* [391] */ MatcherIndex(47), - /* [392] */ MatcherIndex(13), - /* [393] */ MatcherIndex(1), - /* [394] */ MatcherIndex(48), - /* [395] */ MatcherIndex(13), + /* [391] */ MatcherIndex(43), + /* [392] */ MatcherIndex(1), + /* [393] */ MatcherIndex(44), + /* [394] */ MatcherIndex(1), + /* [395] */ MatcherIndex(45), /* [396] */ MatcherIndex(1), - /* [397] */ MatcherIndex(27), - /* [398] */ MatcherIndex(2), - /* [399] */ MatcherIndex(0), - /* [400] */ MatcherIndex(27), - /* [401] */ MatcherIndex(1), - /* [402] */ MatcherIndex(6), - /* [403] */ MatcherIndex(15), - /* [404] */ MatcherIndex(14), - /* [405] */ MatcherIndex(15), - /* [406] */ MatcherIndex(87), - /* [407] */ MatcherIndex(17), - /* [408] */ MatcherIndex(14), - /* [409] */ MatcherIndex(15), - /* [410] */ MatcherIndex(1), - /* [411] */ MatcherIndex(16), - /* [412] */ MatcherIndex(0), - /* [413] */ MatcherIndex(65), + /* [397] */ MatcherIndex(46), + /* [398] */ MatcherIndex(1), + /* [399] */ MatcherIndex(18), + /* [400] */ MatcherIndex(12), + /* [401] */ MatcherIndex(19), + /* [402] */ MatcherIndex(12), + /* [403] */ MatcherIndex(20), + /* [404] */ MatcherIndex(12), + /* [405] */ MatcherIndex(20), + /* [406] */ MatcherIndex(1), + /* [407] */ MatcherIndex(21), + /* [408] */ MatcherIndex(0), + /* [409] */ MatcherIndex(21), + /* [410] */ MatcherIndex(16), + /* [411] */ MatcherIndex(21), + /* [412] */ MatcherIndex(17), + /* [413] */ MatcherIndex(22), /* [414] */ MatcherIndex(0), - /* [415] */ MatcherIndex(63), - /* [416] */ MatcherIndex(0), - /* [417] */ MatcherIndex(15), - /* [418] */ MatcherIndex(13), - /* [419] */ MatcherIndex(17), - /* [420] */ MatcherIndex(13), - /* [421] */ MatcherIndex(17), - /* [422] */ MatcherIndex(11), - /* [423] */ MatcherIndex(17), - /* [424] */ MatcherIndex(12), - /* [425] */ MatcherIndex(38), - /* [426] */ MatcherIndex(0), - /* [427] */ MatcherIndex(39), - /* [428] */ MatcherIndex(0), - /* [429] */ MatcherIndex(40), + /* [415] */ MatcherIndex(22), + /* [416] */ MatcherIndex(16), + /* [417] */ MatcherIndex(22), + /* [418] */ MatcherIndex(17), + /* [419] */ MatcherIndex(23), + /* [420] */ MatcherIndex(16), + /* [421] */ MatcherIndex(23), + /* [422] */ MatcherIndex(17), + /* [423] */ MatcherIndex(24), + /* [424] */ MatcherIndex(0), + /* [425] */ MatcherIndex(24), + /* [426] */ MatcherIndex(16), + /* [427] */ MatcherIndex(24), + /* [428] */ MatcherIndex(17), + /* [429] */ MatcherIndex(25), /* [430] */ MatcherIndex(0), - /* [431] */ MatcherIndex(16), - /* [432] */ MatcherIndex(12), - /* [433] */ MatcherIndex(41), - /* [434] */ MatcherIndex(0), - /* [435] */ MatcherIndex(42), + /* [431] */ MatcherIndex(25), + /* [432] */ MatcherIndex(16), + /* [433] */ MatcherIndex(25), + /* [434] */ MatcherIndex(17), + /* [435] */ MatcherIndex(26), /* [436] */ MatcherIndex(0), - /* [437] */ MatcherIndex(43), - /* [438] */ MatcherIndex(0), - /* [439] */ MatcherIndex(50), - /* [440] */ MatcherIndex(0), - /* [441] */ MatcherIndex(17), + /* [437] */ MatcherIndex(26), + /* [438] */ MatcherIndex(16), + /* [439] */ MatcherIndex(26), + /* [440] */ MatcherIndex(17), + /* [441] */ MatcherIndex(27), /* [442] */ MatcherIndex(0), - /* [443] */ MatcherIndex(37), - /* [444] */ MatcherIndex(2), - /* [445] */ MatcherIndex(37), - /* [446] */ MatcherIndex(1), - /* [447] */ MatcherIndex(37), - /* [448] */ MatcherIndex(9), - /* [449] */ MatcherIndex(15), - /* [450] */ MatcherIndex(11), - /* [451] */ MatcherIndex(37), - /* [452] */ MatcherIndex(3), - /* [453] */ MatcherIndex(16), - /* [454] */ MatcherIndex(13), - /* [455] */ MatcherIndex(38), - /* [456] */ MatcherIndex(13), - /* [457] */ MatcherIndex(37), - /* [458] */ MatcherIndex(0), - /* [459] */ MatcherIndex(39), - /* [460] */ MatcherIndex(13), - /* [461] */ MatcherIndex(40), - /* [462] */ MatcherIndex(13), - /* [463] */ MatcherIndex(41), - /* [464] */ MatcherIndex(13), - /* [465] */ MatcherIndex(16), - /* [466] */ MatcherIndex(11), - /* [467] */ MatcherIndex(42), - /* [468] */ MatcherIndex(13), - /* [469] */ MatcherIndex(43), - /* [470] */ MatcherIndex(13), - /* [471] */ MatcherIndex(15), - /* [472] */ MatcherIndex(0), - /* [473] */ MatcherIndex(16), - /* [474] */ MatcherIndex(1), - /* [475] */ MatcherIndex(62), - /* [476] */ MatcherIndex(0), - /* [477] */ MatcherIndex(67), - /* [478] */ MatcherIndex(0), - /* [479] */ MatcherIndex(38), - /* [480] */ MatcherIndex(1), - /* [481] */ MatcherIndex(39), - /* [482] */ MatcherIndex(1), - /* [483] */ MatcherIndex(40), - /* [484] */ MatcherIndex(1), - /* [485] */ MatcherIndex(41), - /* [486] */ MatcherIndex(1), - /* [487] */ MatcherIndex(42), - /* [488] */ MatcherIndex(1), - /* [489] */ MatcherIndex(43), - /* [490] */ MatcherIndex(1), - /* [491] */ MatcherIndex(50), - /* [492] */ MatcherIndex(1), - /* [493] */ MatcherIndex(15), - /* [494] */ MatcherIndex(9), - /* [495] */ MatcherIndex(16), - /* [496] */ MatcherIndex(9), - /* [497] */ MatcherIndex(17), - /* [498] */ MatcherIndex(9), - /* [499] */ MatcherIndex(17), - /* [500] */ MatcherIndex(1), - /* [501] */ MatcherIndex(18), - /* [502] */ MatcherIndex(0), - /* [503] */ MatcherIndex(18), - /* [504] */ MatcherIndex(13), - /* [505] */ MatcherIndex(18), - /* [506] */ MatcherIndex(14), - /* [507] */ MatcherIndex(19), - /* [508] */ MatcherIndex(0), - /* [509] */ MatcherIndex(19), - /* [510] */ MatcherIndex(13), - /* [511] */ MatcherIndex(19), - /* [512] */ MatcherIndex(14), - /* [513] */ MatcherIndex(23), - /* [514] */ MatcherIndex(0), - /* [515] */ MatcherIndex(23), - /* [516] */ MatcherIndex(13), - /* [517] */ MatcherIndex(23), - /* [518] */ MatcherIndex(14), - /* [519] */ MatcherIndex(24), - /* [520] */ MatcherIndex(0), - /* [521] */ MatcherIndex(24), - /* [522] */ MatcherIndex(13), - /* [523] */ MatcherIndex(24), - /* [524] */ MatcherIndex(14), - /* [525] */ MatcherIndex(25), - /* [526] */ MatcherIndex(0), - /* [527] */ MatcherIndex(25), - /* [528] */ MatcherIndex(13), - /* [529] */ MatcherIndex(25), - /* [530] */ MatcherIndex(14), - /* [531] */ MatcherIndex(26), - /* [532] */ MatcherIndex(13), - /* [533] */ MatcherIndex(26), - /* [534] */ MatcherIndex(14), - /* [535] */ MatcherIndex(79), - /* [536] */ MatcherIndex(83), - /* [537] */ MatcherIndex(91), - /* [538] */ MatcherIndex(85), - /* [539] */ MatcherIndex(72), - /* [540] */ MatcherIndex(80), - /* [541] */ MatcherIndex(71), - /* [542] */ MatcherIndex(10), - /* [543] */ MatcherIndex(51), - /* [544] */ MatcherIndex(52), - /* [545] */ MatcherIndex(53), - /* [546] */ MatcherIndex(54), - /* [547] */ MatcherIndex(55), - /* [548] */ MatcherIndex(60), - /* [549] */ MatcherIndex(35), - /* [550] */ MatcherIndex(36), - /* [551] */ MatcherIndex(86), - /* [552] */ MatcherIndex(90), - /* [553] */ MatcherIndex(92), - /* [554] */ MatcherIndex(93), - /* [555] */ MatcherIndex(73), - /* [556] */ MatcherIndex(84), - /* [557] */ MatcherIndex(76), - /* [558] */ MatcherIndex(77), - /* [559] */ MatcherIndex(74), - /* [560] */ MatcherIndex(75), - /* [561] */ MatcherIndex(78), + /* [443] */ MatcherIndex(27), + /* [444] */ MatcherIndex(16), + /* [445] */ MatcherIndex(27), + /* [446] */ MatcherIndex(17), + /* [447] */ MatcherIndex(28), + /* [448] */ MatcherIndex(0), + /* [449] */ MatcherIndex(28), + /* [450] */ MatcherIndex(16), + /* [451] */ MatcherIndex(28), + /* [452] */ MatcherIndex(17), + /* [453] */ MatcherIndex(29), + /* [454] */ MatcherIndex(0), + /* [455] */ MatcherIndex(29), + /* [456] */ MatcherIndex(16), + /* [457] */ MatcherIndex(29), + /* [458] */ MatcherIndex(17), + /* [459] */ MatcherIndex(75), + /* [460] */ MatcherIndex(79), + /* [461] */ MatcherIndex(87), + /* [462] */ MatcherIndex(81), + /* [463] */ MatcherIndex(68), + /* [464] */ MatcherIndex(76), + /* [465] */ MatcherIndex(67), + /* [466] */ MatcherIndex(47), + /* [467] */ MatcherIndex(48), + /* [468] */ MatcherIndex(49), + /* [469] */ MatcherIndex(50), + /* [470] */ MatcherIndex(51), + /* [471] */ MatcherIndex(56), + /* [472] */ MatcherIndex(38), + /* [473] */ MatcherIndex(39), + /* [474] */ MatcherIndex(13), + /* [475] */ MatcherIndex(82), + /* [476] */ MatcherIndex(86), + /* [477] */ MatcherIndex(88), + /* [478] */ MatcherIndex(89), + /* [479] */ MatcherIndex(69), + /* [480] */ MatcherIndex(80), + /* [481] */ MatcherIndex(72), + /* [482] */ MatcherIndex(73), + /* [483] */ MatcherIndex(70), + /* [484] */ MatcherIndex(71), + /* [485] */ MatcherIndex(74), }; static_assert(MatcherIndicesIndex::CanIndex(kMatcherIndices), @@ -3050,103 +2707,103 @@ constexpr ParameterInfo kParameters[] = { /* [0] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(60), + /* matcher_indices */ MatcherIndicesIndex(80), }, { /* [1] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [2] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [3] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [4] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [5] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [6] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [7] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [8] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [9] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [10] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [11] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [12] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [13] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [14] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [15] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [16] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [17] */ @@ -3164,6013 +2821,3187 @@ constexpr ParameterInfo kParameters[] = { /* [19] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), + /* matcher_indices */ MatcherIndicesIndex(367), }, { /* [20] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [21] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [22] */ /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [23] */ /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [24] */ /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [25] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [26] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(45), }, { /* [27] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), + /* matcher_indices */ MatcherIndicesIndex(345), }, { /* [28] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [29] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [30] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [31] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [32] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(467), }, { /* [33] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(352), + /* matcher_indices */ MatcherIndicesIndex(473), }, { /* [34] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [35] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [36] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [37] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [38] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(367), }, { /* [39] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [40] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(328), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [41] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [42] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [43] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [44] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(365), }, { /* [45] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [46] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [47] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(331), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [48] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [49] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [50] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(369), }, { /* [51] */ - /* usage */ core::ParameterUsage::kDdx, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [52] */ - /* usage */ core::ParameterUsage::kDdy, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [53] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [54] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [55] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(371), }, { /* [56] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), + /* matcher_indices */ MatcherIndicesIndex(375), }, { /* [57] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [58] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [59] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [60] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), + /* usage */ core::ParameterUsage::kDdx, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [61] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kDdy, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [62] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(451), + /* matcher_indices */ MatcherIndicesIndex(367), }, { /* [63] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [64] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [65] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [66] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [67] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(289), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [68] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), + /* matcher_indices */ MatcherIndicesIndex(467), }, { /* [69] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [70] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [71] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [72] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), }, { /* [73] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(292), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [74] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(451), + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(45), }, { /* [75] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(343), }, { /* [76] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [77] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [78] */ - /* usage */ core::ParameterUsage::kComponent, + /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [79] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(295), + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(45), }, { /* [80] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), + /* matcher_indices */ MatcherIndicesIndex(353), }, { /* [81] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [82] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [83] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), }, { /* [84] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(544), + /* matcher_indices */ MatcherIndicesIndex(467), }, { /* [85] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(550), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [86] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [87] */ /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [88] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [89] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), }, { /* [90] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), + /* matcher_indices */ MatcherIndicesIndex(473), }, { /* [91] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [92] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [93] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [94] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(469), }, { /* [95] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(473), }, { /* [96] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [97] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [98] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [99] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(367), }, { /* [100] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [101] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [102] */ - /* usage */ core::ParameterUsage::kTexture, + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(352), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [103] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [104] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(365), }, { /* [105] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [106] */ - /* usage */ core::ParameterUsage::kBias, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(333), }, { /* [107] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [108] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(328), + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { /* [109] */ - /* usage */ core::ParameterUsage::kSampler, + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), + /* matcher_indices */ MatcherIndicesIndex(369), }, { /* [110] */ - /* usage */ core::ParameterUsage::kCoords, + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [111] */ - /* usage */ core::ParameterUsage::kArrayIndex, + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [112] */ /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [113] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), + /* matcher_indices */ MatcherIndicesIndex(371), }, { /* [114] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(331), + /* matcher_indices */ MatcherIndicesIndex(375), }, { /* [115] */ /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), + /* matcher_indices */ MatcherIndicesIndex(472), }, { /* [116] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), + /* matcher_indices */ MatcherIndicesIndex(361), }, { /* [117] */ /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { /* [118] */ /* usage */ core::ParameterUsage::kBias, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(273), }, { /* [119] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [120] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [121] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [122] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [123] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [124] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [125] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [126] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [127] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [128] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [129] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [130] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [131] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [132] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(247), - }, - { - /* [133] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [134] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [135] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [136] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [137] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [138] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(322), - }, - { - /* [139] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [140] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [141] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [142] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [143] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [144] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(325), - }, - { - /* [145] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [146] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [147] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [148] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [149] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [150] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [151] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [152] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [153] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [154] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [155] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [156] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [157] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [158] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [159] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [160] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [161] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [162] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(253), - }, - { - /* [163] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [164] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [165] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [166] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [167] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [168] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(334), - }, - { - /* [169] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [170] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [171] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [172] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [173] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [174] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(337), - }, - { - /* [175] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [176] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [177] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [178] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [179] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [180] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [181] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [182] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [183] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [184] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [185] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [186] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [187] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [188] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [189] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [190] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [191] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [192] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(355), - }, - { - /* [193] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [194] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [195] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [196] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [197] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [198] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(346), - }, - { - /* [199] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [200] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [201] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [202] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [203] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [204] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(349), - }, - { - /* [205] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [206] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [207] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [208] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [209] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [210] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), - }, - { - /* [211] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [212] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [213] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [214] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [215] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [216] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), - }, - { - /* [217] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [218] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [219] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [220] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [221] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [222] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(352), - }, - { - /* [223] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [224] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [225] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [226] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [227] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [228] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(328), - }, - { - /* [229] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [230] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [231] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [232] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [233] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [234] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(331), - }, - { - /* [235] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [236] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [237] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [238] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [239] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [240] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(544), - }, - { - /* [241] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [242] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [243] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [244] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [245] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [246] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [247] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [248] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [249] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [250] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [251] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [252] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [253] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [254] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [255] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [256] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [257] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(286), - }, - { - /* [258] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [259] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [260] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [261] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [262] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(280), - }, - { - /* [263] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [264] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [265] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [266] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [267] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(283), - }, - { - /* [268] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [269] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [270] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [271] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [272] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [273] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [274] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [275] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [276] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [277] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [278] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(451), - }, - { - /* [279] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [280] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [281] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [282] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(307), - }, - { - /* [283] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [284] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [285] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [286] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [287] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(310), - }, - { - /* [288] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(451), - }, - { - /* [289] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [290] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [291] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [292] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(313), - }, - { - /* [293] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [294] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [295] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [296] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(544), - }, - { - /* [297] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [298] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [299] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [300] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [301] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(543), - }, - { - /* [302] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(550), - }, - { - /* [303] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [304] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [305] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [306] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(546), - }, - { - /* [307] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(550), - }, - { - /* [308] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [309] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [310] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [311] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), - }, - { - /* [312] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [313] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [314] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [315] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [316] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(461), - }, - { - /* [317] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [318] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [319] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [320] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [321] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(250), - }, - { - /* [322] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [323] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [324] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [325] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [326] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(328), - }, - { - /* [327] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [328] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [329] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [330] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [331] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(331), - }, - { - /* [332] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [333] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [334] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [335] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [336] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [337] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [338] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [339] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [340] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [341] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [342] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [343] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [344] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [345] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [346] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(247), - }, - { - /* [347] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [348] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [349] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [350] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [351] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(322), - }, - { - /* [352] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [353] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [354] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [355] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [356] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(325), - }, - { - /* [357] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [358] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [359] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [360] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [361] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [362] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [363] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [364] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [365] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [366] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [367] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [368] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [369] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [370] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [371] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(253), - }, - { - /* [372] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [373] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [374] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [375] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [376] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(334), - }, - { - /* [377] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [378] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [379] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [380] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [381] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(337), - }, - { - /* [382] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [383] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [384] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [385] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [386] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [387] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [388] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [389] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [390] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [391] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [392] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [393] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [394] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [395] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [396] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(355), - }, - { - /* [397] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [398] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [399] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [400] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [401] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(346), - }, - { - /* [402] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [403] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [404] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [405] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [406] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(349), - }, - { - /* [407] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [408] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [409] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [410] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [411] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(467), - }, - { - /* [412] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [413] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [414] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [415] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [416] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(467), - }, - { - /* [417] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [418] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [419] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [420] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [421] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(256), - }, - { - /* [422] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [423] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [424] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [425] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [426] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(340), - }, - { - /* [427] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [428] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [429] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [430] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [431] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(340), - }, - { - /* [432] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [433] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [434] */ - /* usage */ core::ParameterUsage::kDdx, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [435] */ - /* usage */ core::ParameterUsage::kDdy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [436] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [437] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [438] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [439] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [440] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [441] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [442] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [443] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [444] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [445] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [446] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(247), - }, - { - /* [447] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [448] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [449] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [450] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [451] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(322), - }, - { - /* [452] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [453] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [454] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [455] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [456] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(325), - }, - { - /* [457] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [458] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [459] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [460] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [461] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [462] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [463] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [464] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [465] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [466] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [467] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [468] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [469] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [470] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [471] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(253), - }, - { - /* [472] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [473] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [474] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [475] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [476] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(334), - }, - { - /* [477] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [478] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [479] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [480] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [481] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(337), - }, - { - /* [482] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [483] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [484] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [485] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [486] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [487] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [488] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [489] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [490] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [491] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [492] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [493] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [494] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [495] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [496] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(355), - }, - { - /* [497] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [498] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [499] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [500] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [501] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(346), - }, - { - /* [502] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [503] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [504] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [505] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [506] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(349), - }, - { - /* [507] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [508] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [509] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [510] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [511] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(543), - }, - { - /* [512] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [513] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [514] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [515] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [516] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(546), - }, - { - /* [517] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [518] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [519] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [520] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [521] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(86), - }, - { - /* [522] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [523] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [524] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [525] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [526] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(28), - }, - { - /* [527] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [528] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [529] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [530] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [531] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(96), - }, - { - /* [532] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [533] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [534] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [535] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [536] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(101), - }, - { - /* [537] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [538] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [539] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [540] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [541] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(35), - }, - { - /* [542] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [543] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [544] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [545] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [546] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(42), - }, - { - /* [547] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [548] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [549] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [550] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [551] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [552] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [553] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [554] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [555] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [556] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(277), - }, - { - /* [557] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [558] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [559] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [560] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(280), - }, - { - /* [561] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [562] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [563] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [564] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [565] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [566] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [567] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [568] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [569] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(443), - }, - { - /* [570] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [571] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [572] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(298), - }, - { - /* [573] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [574] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [575] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [576] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(301), - }, - { - /* [577] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(445), - }, - { - /* [578] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [579] */ - /* usage */ core::ParameterUsage::kComponent, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [580] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(304), - }, - { - /* [581] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [582] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [583] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(543), - }, - { - /* [584] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [585] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [586] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [587] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(545), - }, - { - /* [588] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(550), - }, - { - /* [589] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [590] */ - /* usage */ core::ParameterUsage::kDepthRef, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [591] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [592] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [593] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [594] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [595] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(459), - }, - { - /* [596] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [597] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [598] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [599] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(247), - }, - { - /* [600] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [601] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [602] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [603] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(322), - }, - { - /* [604] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [605] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [606] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [607] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(325), - }, - { - /* [608] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [609] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [610] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(449), - }, - { - /* [611] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [612] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [613] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [614] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [615] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(463), - }, - { - /* [616] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [617] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [618] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [619] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(253), - }, - { - /* [620] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [621] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [622] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [623] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(334), - }, - { - /* [624] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [625] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [626] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [627] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(337), - }, - { - /* [628] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [629] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [630] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(465), - }, - { - /* [631] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(469), - }, - { - /* [632] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [633] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [634] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [635] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(259), - }, - { - /* [636] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [637] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [638] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [639] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(346), - }, - { - /* [640] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [641] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [642] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [643] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(467), - }, - { - /* [644] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [645] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [646] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [647] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(467), - }, - { - /* [648] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [649] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [650] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [651] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(256), - }, - { - /* [652] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [653] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [654] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [655] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(340), - }, - { - /* [656] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [657] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [658] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [659] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(343), - }, - { - /* [660] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [661] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [662] */ - /* usage */ core::ParameterUsage::kBias, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [663] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(455), - }, - { - /* [664] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [665] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [666] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [667] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(455), - }, - { - /* [668] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [669] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [670] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [671] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(244), - }, - { - /* [672] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [673] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [674] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [675] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(316), - }, - { - /* [676] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [677] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [678] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [679] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(319), - }, - { - /* [680] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [681] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [682] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [683] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(467), - }, - { - /* [684] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [685] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [686] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [687] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(467), - }, - { - /* [688] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [689] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [690] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [691] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(256), - }, - { - /* [692] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [693] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [694] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [695] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(340), - }, - { - /* [696] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(457), - }, - { - /* [697] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [698] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [699] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(343), - }, - { - /* [700] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(447), - }, - { - /* [701] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [702] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [703] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(545), - }, - { - /* [704] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [705] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(453), - }, - { - /* [706] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [707] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(364), - }, - { - /* [708] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [709] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(69), - }, - { - /* [710] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [711] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(364), - }, - { - /* [712] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [713] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(69), - }, - { - /* [714] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [715] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(364), - }, - { - /* [716] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [717] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(69), - }, - { - /* [718] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [719] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), - }, - { - /* [720] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(409), - }, - { - /* [721] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [722] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(69), - }, - { - /* [723] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(379), - }, - { - /* [724] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(409), - }, - { - /* [725] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [726] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(69), - }, - { - /* [727] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(544), - }, - { - /* [728] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [729] */ - /* usage */ core::ParameterUsage::kArrayIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [730] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [731] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(71), - }, - { - /* [732] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [733] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [734] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [735] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(7), - }, - { - /* [736] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [737] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [738] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [739] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(76), - }, - { - /* [740] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [741] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [742] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [743] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(81), - }, - { - /* [744] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [745] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [746] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [747] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(14), - }, - { - /* [748] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [749] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [750] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [751] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(21), - }, - { - /* [752] */ - /* usage */ core::ParameterUsage::kOffset, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [753] */ - /* usage */ core::ParameterUsage::kColMajor, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [754] */ - /* usage */ core::ParameterUsage::kStride, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [755] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [756] */ - /* usage */ core::ParameterUsage::kY, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [757] */ - /* usage */ core::ParameterUsage::kZ, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [758] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [759] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [760] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [761] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [762] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [763] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [764] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [765] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [766] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [767] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [768] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [769] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [770] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(441), - }, - { - /* [771] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(214), - }, - { - /* [772] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(214), - }, - { - /* [773] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(214), - }, - { - /* [774] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [775] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [776] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [777] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [778] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [779] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [780] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [781] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [782] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(213), - }, - { - /* [783] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [784] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [785] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(211), - }, - { - /* [786] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(211), - }, - { - /* [787] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(548), - }, - { - /* [788] */ - /* usage */ core::ParameterUsage::kSampler, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(549), - }, - { - /* [789] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [790] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(358), - }, - { - /* [791] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [792] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [793] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(361), - }, - { - /* [794] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [795] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [796] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(367), - }, - { - /* [797] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [798] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [799] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(370), - }, - { - /* [800] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [801] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [802] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(358), - }, - { - /* [803] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [804] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [805] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(361), - }, - { - /* [806] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [807] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [808] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(367), - }, - { - /* [809] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [810] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [811] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(370), - }, - { - /* [812] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [813] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [814] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(358), - }, - { - /* [815] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [816] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [817] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(361), - }, - { - /* [818] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [819] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [820] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(367), - }, - { - /* [821] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [822] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [823] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(370), - }, - { - /* [824] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [825] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [826] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [827] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [828] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [829] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [830] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(409), - }, - { - /* [831] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [832] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(433), - }, - { - /* [833] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(473), - }, - { - /* [834] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [835] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(373), }, { - /* [836] */ + /* [120] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [121] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), + /* matcher_indices */ MatcherIndicesIndex(361), }, { - /* [837] */ - /* usage */ core::ParameterUsage::kLevel, + /* [122] */ + /* usage */ core::ParameterUsage::kDdx, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(361), }, { - /* [838] */ + /* [123] */ + /* usage */ core::ParameterUsage::kDdy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [124] */ /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(376), + /* matcher_indices */ MatcherIndicesIndex(365), }, { - /* [839] */ + /* [125] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [126] */ /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(409), + /* matcher_indices */ MatcherIndicesIndex(333), }, { - /* [840] */ + /* [127] */ /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), + /* matcher_indices */ MatcherIndicesIndex(273), }, { - /* [841] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(382), - }, - { - /* [842] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(473), - }, - { - /* [843] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [844] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(439), - }, - { - /* [845] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(409), - }, - { - /* [846] */ - /* usage */ core::ParameterUsage::kSampleIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [847] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(543), - }, - { - /* [848] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [849] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [850] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(547), - }, - { - /* [851] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [852] */ - /* usage */ core::ParameterUsage::kSampleIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [853] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(126), - }, - { - /* [854] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(131), - }, - { - /* [855] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(121), - }, - { - /* [856] */ - /* usage */ core::ParameterUsage::kXy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [857] */ - /* usage */ core::ParameterUsage::kZ, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [858] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [859] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [860] */ - /* usage */ core::ParameterUsage::kYz, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [861] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [862] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [863] */ - /* usage */ core::ParameterUsage::kY, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [864] */ - /* usage */ core::ParameterUsage::kZw, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [865] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [866] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [867] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [868] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(238), - }, - { - /* [869] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(425), - }, - { - /* [870] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [871] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(427), - }, - { - /* [872] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [873] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(429), - }, - { - /* [874] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [875] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(433), - }, - { - /* [876] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [877] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(435), - }, - { - /* [878] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [879] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(437), - }, - { - /* [880] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [881] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(244), - }, - { - /* [882] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [883] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(247), - }, - { - /* [884] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [885] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(250), - }, - { - /* [886] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [887] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(253), - }, - { - /* [888] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [889] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(256), - }, - { - /* [890] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [891] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(259), - }, - { - /* [892] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [893] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(543), - }, - { - /* [894] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [895] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(544), - }, - { - /* [896] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [897] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(545), - }, - { - /* [898] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [899] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(546), - }, - { - /* [900] */ - /* usage */ core::ParameterUsage::kLevel, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [901] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(548), - }, - { - /* [902] */ - /* usage */ core::ParameterUsage::kCoords, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [903] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(0), - }, - { - /* [904] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(3), - }, - { - /* [905] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [906] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* [128] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(537), + /* matcher_indices */ MatcherIndicesIndex(359), }, { - /* [907] */ - /* usage */ core::ParameterUsage::kValue, + /* [129] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), + /* matcher_indices */ MatcherIndicesIndex(369), }, { - /* [908] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* [130] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [131] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [132] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), + }, + { + /* [133] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(537), + /* matcher_indices */ MatcherIndicesIndex(371), }, { - /* [909] */ - /* usage */ core::ParameterUsage::kValue, + /* [134] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(375), }, { - /* [910] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* [135] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(537), + /* matcher_indices */ MatcherIndicesIndex(472), }, { - /* [911] */ - /* usage */ core::ParameterUsage::kValue, + /* [136] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), + /* matcher_indices */ MatcherIndicesIndex(361), }, { - /* [912] */ - /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* [137] */ + /* usage */ core::ParameterUsage::kArrayIndex, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(537), + /* matcher_indices */ MatcherIndicesIndex(61), }, { - /* [913] */ - /* usage */ core::ParameterUsage::kValue, + /* [138] */ + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(273), }, { - /* [914] */ - /* usage */ core::ParameterUsage::kMask, + /* [139] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), + /* matcher_indices */ MatcherIndicesIndex(466), }, { - /* [915] */ - /* usage */ core::ParameterUsage::kValue, + /* [140] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), + /* matcher_indices */ MatcherIndicesIndex(472), }, { - /* [916] */ - /* usage */ core::ParameterUsage::kMask, + /* [141] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), + /* matcher_indices */ MatcherIndicesIndex(333), }, { - /* [917] */ - /* usage */ core::ParameterUsage::kValue, + /* [142] */ + /* usage */ core::ParameterUsage::kLevel, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(61), }, { - /* [918] */ - /* usage */ core::ParameterUsage::kDelta, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [919] */ - /* usage */ core::ParameterUsage::kValue, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), - }, - { - /* [920] */ - /* usage */ core::ParameterUsage::kDelta, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [921] */ - /* usage */ core::ParameterUsage::kE, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [922] */ - /* usage */ core::ParameterUsage::kId, + /* [143] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(537), + /* matcher_indices */ MatcherIndicesIndex(359), }, { - /* [923] */ - /* usage */ core::ParameterUsage::kE, + /* [144] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(208), + /* matcher_indices */ MatcherIndicesIndex(469), }, { - /* [924] */ - /* usage */ core::ParameterUsage::kId, - /* is_const */ true, - /* matcher_indices */ MatcherIndicesIndex(537), + /* [145] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), }, { - /* [925] */ + /* [146] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [147] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [148] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [149] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(111), + /* matcher_indices */ MatcherIndicesIndex(125), }, { - /* [926] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(116), - }, - { - /* [927] */ - /* usage */ core::ParameterUsage::kM, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(91), - }, - { - /* [928] */ - /* usage */ core::ParameterUsage::kS, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [929] */ - /* usage */ core::ParameterUsage::kM, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(136), - }, - { - /* [930] */ - /* usage */ core::ParameterUsage::kS, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), - }, - { - /* [931] */ - /* usage */ core::ParameterUsage::kM, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(141), - }, - { - /* [932] */ - /* usage */ core::ParameterUsage::kS, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(4), - }, - { - /* [933] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(146), - }, - { - /* [934] */ + /* [150] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [935] */ + /* [151] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(146), + /* matcher_indices */ MatcherIndicesIndex(130), }, { - /* [936] */ - /* usage */ core::ParameterUsage::kOffset, + /* [152] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [153] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [937] */ + /* [154] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(176), + /* matcher_indices */ MatcherIndicesIndex(42), }, { - /* [938] */ + /* [155] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [939] */ + /* [156] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(176), + /* matcher_indices */ MatcherIndicesIndex(130), }, { - /* [940] */ + /* [157] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [158] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [159] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(135), + }, + { + /* [160] */ /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [941] */ + /* [161] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(214), + /* matcher_indices */ MatcherIndicesIndex(130), }, { - /* [942] */ + /* [162] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [163] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [164] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), + /* matcher_indices */ MatcherIndicesIndex(140), }, { - /* [943] */ + /* [165] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [166] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(214), + /* matcher_indices */ MatcherIndicesIndex(130), }, { - /* [944] */ + /* [167] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [168] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [169] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(226), + /* matcher_indices */ MatcherIndicesIndex(48), }, { - /* [945] */ + /* [170] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [171] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(192), + /* matcher_indices */ MatcherIndicesIndex(130), }, { - /* [946] */ - /* usage */ core::ParameterUsage::kNone, + /* [172] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [173] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(192), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [947] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [948] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(192), - }, - { - /* [949] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(214), - }, - { - /* [950] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(397), - }, - { - /* [951] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(192), - }, - { - /* [952] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(200), - }, - { - /* [953] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(204), - }, - { - /* [954] */ - /* usage */ core::ParameterUsage::kXy, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [955] */ - /* usage */ core::ParameterUsage::kZw, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(471), - }, - { - /* [956] */ - /* usage */ core::ParameterUsage::kXyz, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [957] */ - /* usage */ core::ParameterUsage::kW, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [958] */ - /* usage */ core::ParameterUsage::kX, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(6), - }, - { - /* [959] */ - /* usage */ core::ParameterUsage::kZyw, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(411), - }, - { - /* [960] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(49), - }, - { - /* [961] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(27), - }, - { - /* [962] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(231), - }, - { - /* [963] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(403), - }, - { - /* [964] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(407), - }, - { - /* [965] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(220), - }, - { - /* [966] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(223), - }, - { - /* [967] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(229), - }, - { - /* [968] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(409), - }, - { - /* [969] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(156), - }, - { - /* [970] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(20), - }, - { - /* [971] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(232), - }, - { - /* [972] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(417), - }, - { - /* [973] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(419), - }, - { - /* [974] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(421), - }, - { - /* [975] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(423), - }, - { - /* [976] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(164), - }, - { - /* [977] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(168), - }, - { - /* [978] */ + /* [174] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(54), }, { - /* [979] */ - /* usage */ core::ParameterUsage::kTexture, + /* [175] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(262), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [980] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(265), - }, - { - /* [981] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(268), - }, - { - /* [982] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(271), - }, - { - /* [983] */ - /* usage */ core::ParameterUsage::kTexture, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(274), - }, - { - /* [984] */ - /* usage */ core::ParameterUsage::kInputAttachment, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(475), - }, - { - /* [985] */ + /* [176] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(130), + }, + { + /* [177] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, /* matcher_indices */ MatcherIndicesIndex(151), }, { - /* [986] */ + /* [178] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [179] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(180), + /* matcher_indices */ MatcherIndicesIndex(247), }, { - /* [987] */ - /* usage */ core::ParameterUsage::kIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(10), - }, - { - /* [988] */ - /* usage */ core::ParameterUsage::kIndex, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(31), - }, - { - /* [989] */ + /* [180] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(188), + /* matcher_indices */ MatcherIndicesIndex(247), }, { - /* [990] */ + /* [181] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(184), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [991] */ + /* [182] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [992] */ - /* usage */ core::ParameterUsage::kNone, + /* [183] */ + /* usage */ core::ParameterUsage::kComponent, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [184] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(351), + }, + { + /* [185] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [186] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [187] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), + }, + { + /* [188] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [189] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(333), + }, + { + /* [190] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), + }, + { + /* [191] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(468), + }, + { + /* [192] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(473), }, { - /* [993] */ - /* usage */ core::ParameterUsage::kNone, + /* [193] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(499), + /* matcher_indices */ MatcherIndicesIndex(361), }, { - /* [994] */ - /* usage */ core::ParameterUsage::kNone, + /* [194] */ + /* usage */ core::ParameterUsage::kDepthRef, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(501), + /* matcher_indices */ MatcherIndicesIndex(273), }, { - /* [995] */ - /* usage */ core::ParameterUsage::kNone, + /* [195] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(503), + /* matcher_indices */ MatcherIndicesIndex(365), }, { - /* [996] */ - /* usage */ core::ParameterUsage::kNone, + /* [196] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(505), + /* matcher_indices */ MatcherIndicesIndex(472), }, { - /* [997] */ - /* usage */ core::ParameterUsage::kNone, + /* [197] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(507), + /* matcher_indices */ MatcherIndicesIndex(333), }, { - /* [998] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(509), + /* [198] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(359), }, { - /* [999] */ - /* usage */ core::ParameterUsage::kNone, + /* [199] */ + /* usage */ core::ParameterUsage::kTexture, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(511), + /* matcher_indices */ MatcherIndicesIndex(369), }, { - /* [1000] */ - /* usage */ core::ParameterUsage::kNone, + /* [200] */ + /* usage */ core::ParameterUsage::kSampler, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(5), + /* matcher_indices */ MatcherIndicesIndex(472), }, { - /* [1001] */ - /* usage */ core::ParameterUsage::kNone, + /* [201] */ + /* usage */ core::ParameterUsage::kCoords, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(58), + /* matcher_indices */ MatcherIndicesIndex(361), }, { - /* [1002] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(64), + /* [202] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(371), }, { - /* [1003] */ + /* [203] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(373), + }, + { + /* [204] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [205] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [206] */ + /* usage */ core::ParameterUsage::kBias, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), + }, + { + /* [207] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(363), + }, + { + /* [208] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [209] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), + }, + { + /* [210] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), + }, + { + /* [211] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(373), + }, + { + /* [212] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [213] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [214] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), + }, + { + /* [215] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(468), + }, + { + /* [216] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [217] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(361), + }, + { + /* [218] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [219] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(304), + }, + { + /* [220] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [221] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(27), + }, + { + /* [222] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(335), + }, + { + /* [223] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(304), + }, + { + /* [224] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [225] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(27), + }, + { + /* [226] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(337), + }, + { + /* [227] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(304), + }, + { + /* [228] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [229] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(27), + }, + { + /* [230] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(339), + }, + { + /* [231] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(345), + }, + { + /* [232] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(325), + }, + { + /* [233] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [234] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(27), + }, + { + /* [235] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(467), + }, + { + /* [236] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [237] */ + /* usage */ core::ParameterUsage::kArrayIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [238] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [239] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(90), + }, + { + /* [240] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [241] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [242] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [243] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(6), + }, + { + /* [244] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [245] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [246] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [247] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(95), + }, + { + /* [248] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [249] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [250] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [251] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(100), + }, + { + /* [252] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [253] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [254] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [255] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, /* matcher_indices */ MatcherIndicesIndex(12), }, { - /* [1004] */ - /* usage */ core::ParameterUsage::kNone, + /* [256] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(19), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1005] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(26), + /* [257] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), }, { - /* [1006] */ - /* usage */ core::ParameterUsage::kNone, + /* [258] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(33), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1007] */ + /* [259] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(40), + /* matcher_indices */ MatcherIndicesIndex(18), }, { - /* [1008] */ - /* usage */ core::ParameterUsage::kNone, + /* [260] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(47), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1009] */ - /* usage */ core::ParameterUsage::kNone, - /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(513), + /* [261] */ + /* usage */ core::ParameterUsage::kColMajor, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(151), }, { - /* [1010] */ - /* usage */ core::ParameterUsage::kNone, + /* [262] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(515), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1011] */ + /* [263] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(517), + /* matcher_indices */ MatcherIndicesIndex(90), }, { - /* [1012] */ - /* usage */ core::ParameterUsage::kNone, + /* [264] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(519), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1013] */ + /* [265] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(521), + /* matcher_indices */ MatcherIndicesIndex(85), }, { - /* [1014] */ - /* usage */ core::ParameterUsage::kNone, + /* [266] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(523), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1015] */ + /* [267] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(525), + /* matcher_indices */ MatcherIndicesIndex(6), }, { - /* [1016] */ - /* usage */ core::ParameterUsage::kNone, + /* [268] */ + /* usage */ core::ParameterUsage::kOffset, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(527), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1017] */ + /* [269] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(529), + /* matcher_indices */ MatcherIndicesIndex(85), }, { - /* [1018] */ - /* usage */ core::ParameterUsage::kNone, + /* [270] */ + /* usage */ core::ParameterUsage::kStride, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(169), + /* matcher_indices */ MatcherIndicesIndex(4), }, { - /* [1019] */ + /* [271] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(531), + /* matcher_indices */ MatcherIndicesIndex(95), }, { - /* [1020] */ + /* [272] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [273] */ /* usage */ core::ParameterUsage::kNone, /* is_const */ false, - /* matcher_indices */ MatcherIndicesIndex(533), + /* matcher_indices */ MatcherIndicesIndex(85), + }, + { + /* [274] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [275] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(100), + }, + { + /* [276] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [277] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(85), + }, + { + /* [278] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [279] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(12), + }, + { + /* [280] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [281] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(85), + }, + { + /* [282] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [283] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(18), + }, + { + /* [284] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [285] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(85), + }, + { + /* [286] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [287] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [288] */ + /* usage */ core::ParameterUsage::kY, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [289] */ + /* usage */ core::ParameterUsage::kZ, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [290] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [291] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [292] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [293] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [294] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [295] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [296] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [297] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [298] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [299] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(357), + }, + { + /* [300] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(357), + }, + { + /* [301] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(357), + }, + { + /* [302] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(357), + }, + { + /* [303] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [304] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [305] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [306] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [307] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [308] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [309] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [310] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [311] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [312] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [313] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [314] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(151), + }, + { + /* [315] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [316] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [317] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(250), + }, + { + /* [318] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(250), + }, + { + /* [319] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(471), + }, + { + /* [320] */ + /* usage */ core::ParameterUsage::kSampler, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(472), + }, + { + /* [321] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(333), + }, + { + /* [322] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(298), + }, + { + /* [323] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [324] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(335), + }, + { + /* [325] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(301), + }, + { + /* [326] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [327] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(335), + }, + { + /* [328] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(307), + }, + { + /* [329] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [330] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(335), + }, + { + /* [331] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(310), + }, + { + /* [332] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [333] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(335), + }, + { + /* [334] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(298), + }, + { + /* [335] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [336] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(337), + }, + { + /* [337] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(301), + }, + { + /* [338] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [339] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(337), + }, + { + /* [340] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(307), + }, + { + /* [341] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [342] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(337), + }, + { + /* [343] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(310), + }, + { + /* [344] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [345] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(337), + }, + { + /* [346] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(298), + }, + { + /* [347] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [348] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(339), + }, + { + /* [349] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(301), + }, + { + /* [350] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [351] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(339), + }, + { + /* [352] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(307), + }, + { + /* [353] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [354] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(339), + }, + { + /* [355] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(310), + }, + { + /* [356] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [357] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(339), + }, + { + /* [358] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(341), + }, + { + /* [359] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [360] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [361] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(343), + }, + { + /* [362] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(325), + }, + { + /* [363] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [364] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(349), + }, + { + /* [365] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(379), + }, + { + /* [366] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [367] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(355), + }, + { + /* [368] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(325), + }, + { + /* [369] */ + /* usage */ core::ParameterUsage::kSampleIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [370] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), + }, + { + /* [371] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [372] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [373] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(470), + }, + { + /* [374] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [375] */ + /* usage */ core::ParameterUsage::kSampleIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [376] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(110), + }, + { + /* [377] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [378] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [379] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(24), + }, + { + /* [380] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [381] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [382] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(115), + }, + { + /* [383] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [384] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [385] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(120), + }, + { + /* [386] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [387] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [388] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(30), + }, + { + /* [389] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [390] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [391] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(36), + }, + { + /* [392] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [393] */ + /* usage */ core::ParameterUsage::kStride, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [394] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(165), + }, + { + /* [395] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(170), + }, + { + /* [396] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(160), + }, + { + /* [397] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(185), + }, + { + /* [398] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(46), + }, + { + /* [399] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(10), + }, + { + /* [400] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(215), + }, + { + /* [401] */ + /* usage */ core::ParameterUsage::kOffset, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(27), + }, + { + /* [402] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(46), + }, + { + /* [403] */ + /* usage */ core::ParameterUsage::kXy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [404] */ + /* usage */ core::ParameterUsage::kZ, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [405] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [406] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [407] */ + /* usage */ core::ParameterUsage::kYz, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [408] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [409] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [410] */ + /* usage */ core::ParameterUsage::kY, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [411] */ + /* usage */ core::ParameterUsage::kZw, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [412] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [413] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [414] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [415] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(277), + }, + { + /* [416] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(341), + }, + { + /* [417] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [418] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(343), + }, + { + /* [419] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [420] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(345), + }, + { + /* [421] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [422] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(349), + }, + { + /* [423] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [424] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(351), + }, + { + /* [425] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [426] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(353), + }, + { + /* [427] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [428] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(466), + }, + { + /* [429] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [430] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(467), + }, + { + /* [431] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [432] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(468), + }, + { + /* [433] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [434] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(469), + }, + { + /* [435] */ + /* usage */ core::ParameterUsage::kLevel, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [436] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(471), + }, + { + /* [437] */ + /* usage */ core::ParameterUsage::kCoords, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [438] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(0), + }, + { + /* [439] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(3), + }, + { + /* [440] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [441] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [442] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [443] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [444] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [445] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [446] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [447] */ + /* usage */ core::ParameterUsage::kSourceLaneIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [448] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [449] */ + /* usage */ core::ParameterUsage::kMask, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [450] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [451] */ + /* usage */ core::ParameterUsage::kMask, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [452] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [453] */ + /* usage */ core::ParameterUsage::kDelta, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [454] */ + /* usage */ core::ParameterUsage::kValue, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [455] */ + /* usage */ core::ParameterUsage::kDelta, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [456] */ + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [457] */ + /* usage */ core::ParameterUsage::kId, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [458] */ + /* usage */ core::ParameterUsage::kE, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(247), + }, + { + /* [459] */ + /* usage */ core::ParameterUsage::kId, + /* is_const */ true, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [460] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(150), + }, + { + /* [461] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(155), + }, + { + /* [462] */ + /* usage */ core::ParameterUsage::kM, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(130), + }, + { + /* [463] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [464] */ + /* usage */ core::ParameterUsage::kM, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(175), + }, + { + /* [465] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [466] */ + /* usage */ core::ParameterUsage::kM, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(180), + }, + { + /* [467] */ + /* usage */ core::ParameterUsage::kS, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(4), + }, + { + /* [468] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [469] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [470] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [471] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(265), + }, + { + /* [472] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(231), + }, + { + /* [473] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(231), + }, + { + /* [474] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [475] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(231), + }, + { + /* [476] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(253), + }, + { + /* [477] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(313), + }, + { + /* [478] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(231), + }, + { + /* [479] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(239), + }, + { + /* [480] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(243), + }, + { + /* [481] */ + /* usage */ core::ParameterUsage::kXy, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [482] */ + /* usage */ core::ParameterUsage::kZw, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(377), + }, + { + /* [483] */ + /* usage */ core::ParameterUsage::kXyz, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [484] */ + /* usage */ core::ParameterUsage::kW, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [485] */ + /* usage */ core::ParameterUsage::kX, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(61), + }, + { + /* [486] */ + /* usage */ core::ParameterUsage::kZyw, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(327), + }, + { + /* [487] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(60), + }, + { + /* [488] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(65), + }, + { + /* [489] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(70), + }, + { + /* [490] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(5), + }, + { + /* [491] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(270), + }, + { + /* [492] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(319), + }, + { + /* [493] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(323), + }, + { + /* [494] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(259), + }, + { + /* [495] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(262), + }, + { + /* [496] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(268), + }, + { + /* [497] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(325), + }, + { + /* [498] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(195), + }, + { + /* [499] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(273), + }, + { + /* [500] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(271), + }, + { + /* [501] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(333), + }, + { + /* [502] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(335), + }, + { + /* [503] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(337), + }, + { + /* [504] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(339), + }, + { + /* [505] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(203), + }, + { + /* [506] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(207), + }, + { + /* [507] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(75), + }, + { + /* [508] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(283), + }, + { + /* [509] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(286), + }, + { + /* [510] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(289), + }, + { + /* [511] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(292), + }, + { + /* [512] */ + /* usage */ core::ParameterUsage::kTexture, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(295), + }, + { + /* [513] */ + /* usage */ core::ParameterUsage::kInputAttachment, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(381), + }, + { + /* [514] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(190), + }, + { + /* [515] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(219), + }, + { + /* [516] */ + /* usage */ core::ParameterUsage::kIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(9), + }, + { + /* [517] */ + /* usage */ core::ParameterUsage::kIndex, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(45), + }, + { + /* [518] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(227), + }, + { + /* [519] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(223), + }, + { + /* [520] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(15), + }, + { + /* [521] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(379), + }, + { + /* [522] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(405), + }, + { + /* [523] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(407), + }, + { + /* [524] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(409), + }, + { + /* [525] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(411), + }, + { + /* [526] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(413), + }, + { + /* [527] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(415), + }, + { + /* [528] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(417), + }, + { + /* [529] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(208), + }, + { + /* [530] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(419), + }, + { + /* [531] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(421), + }, + { + /* [532] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(423), + }, + { + /* [533] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(425), + }, + { + /* [534] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(427), + }, + { + /* [535] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(429), + }, + { + /* [536] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(431), + }, + { + /* [537] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(433), + }, + { + /* [538] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(435), + }, + { + /* [539] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(437), + }, + { + /* [540] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(439), + }, + { + /* [541] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(441), + }, + { + /* [542] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(443), + }, + { + /* [543] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(445), + }, + { + /* [544] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(447), + }, + { + /* [545] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(449), + }, + { + /* [546] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(451), + }, + { + /* [547] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(453), + }, + { + /* [548] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(455), + }, + { + /* [549] */ + /* usage */ core::ParameterUsage::kNone, + /* is_const */ false, + /* matcher_indices */ MatcherIndicesIndex(457), }, }; @@ -9181,325 +6012,325 @@ constexpr TemplateInfo kTemplates[] = { { /* [0] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(66), + /* matcher_indices */ MatcherIndicesIndex(105), /* kind */ TemplateInfo::Kind::kType, }, { /* [1] */ - /* name */ "K", + /* name */ "Majorness", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [2] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(551), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [3] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, }, { /* [4] */ - /* name */ "R", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [5] */ - /* name */ "AC", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [6] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(66), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [7] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [8] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(138), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [9] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [10] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [11] */ /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [12] */ + /* [7] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [8] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [9] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(66), + /* matcher_indices */ MatcherIndicesIndex(105), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [10] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, + { + /* [11] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [12] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(156), /* kind */ TemplateInfo::Kind::kType, }, { /* [13] */ - /* name */ "K", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [14] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(143), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [15] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [16] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [17] */ + /* [15] */ /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [16] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [17] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, + }, { /* [18] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(105), /* kind */ TemplateInfo::Kind::kType, }, { /* [19] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [20] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [21] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(146), /* kind */ TemplateInfo::Kind::kType, }, { /* [22] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [23] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [24] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [25] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [26] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [27] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(552), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [28] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(27), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [29] */ /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [30] */ + /* [23] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [24] */ + /* name */ "AC", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [25] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [26] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [27] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(85), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [28] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [29] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [30] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, { /* [31] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [32] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(551), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AC", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [33] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [34] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [35] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(20), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(85), /* kind */ TemplateInfo::Kind::kType, }, { /* [36] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [37] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(156), + /* kind */ TemplateInfo::Kind::kType, }, { /* [38] */ - /* name */ "R", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [39] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [40] */ - /* name */ "C", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [41] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [42] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(553), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [43] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(554), + /* matcher_indices */ MatcherIndicesIndex(85), /* kind */ TemplateInfo::Kind::kType, }, { /* [44] */ - /* name */ "C", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [45] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(146), + /* kind */ TemplateInfo::Kind::kType, }, { /* [46] */ - /* name */ "K", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [47] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [48] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [49] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [50] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [51] */ - /* name */ "K", + /* [48] */ + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [49] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [50] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [51] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, { /* [52] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(27), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [53] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(552), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(475), /* kind */ TemplateInfo::Kind::kType, }, { @@ -9516,477 +6347,477 @@ constexpr TemplateInfo kTemplates[] = { }, { /* [56] */ - /* name */ "K", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [57] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [58] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [59] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, + { + /* [60] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [61] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(156), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [62] */ /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [60] */ + /* [63] */ /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [61] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [62] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(554), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [63] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(553), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [64] */ - /* name */ "C", + /* name */ "AC", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [65] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [66] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [67] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [68] */ - /* name */ "TR", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [69] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(146), + /* kind */ TemplateInfo::Kind::kType, }, { /* [70] */ - /* name */ "R", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [71] */ - /* name */ "K", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [72] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [73] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [74] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [75] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), + /* name */ "AC", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [76] */ + /* [73] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [74] */ + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [75] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(105), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [76] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, { /* [77] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [78] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(475), /* kind */ TemplateInfo::Kind::kType, }, { /* [79] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [80] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [81] */ - /* name */ "F", + /* name */ "AM", /* matcher_indices */ MatcherIndicesIndex(3), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [82] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(33), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(105), + /* kind */ TemplateInfo::Kind::kType, }, { /* [83] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [84] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [85] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(411), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(156), + /* kind */ TemplateInfo::Kind::kType, }, { /* [86] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(33), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [87] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [88] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [89] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(407), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [90] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(33), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [91] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(105), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [90] */ + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, + }, + { + /* [91] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, { /* [92] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(219), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(146), /* kind */ TemplateInfo::Kind::kType, }, { /* [93] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [94] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [95] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [96] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(85), /* kind */ TemplateInfo::Kind::kType, }, { /* [97] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [98] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(475), /* kind */ TemplateInfo::Kind::kType, }, { /* [99] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [100] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [101] */ - /* name */ "F", + /* name */ "AM", /* matcher_indices */ MatcherIndicesIndex(3), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [102] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(501), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [103] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(85), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [103] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, { /* [104] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(156), /* kind */ TemplateInfo::Kind::kType, }, { /* [105] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(411), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [106] */ /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(501), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [107] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(3), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [108] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(85), /* kind */ TemplateInfo::Kind::kType, }, { /* [109] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(407), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [110] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(501), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(146), + /* kind */ TemplateInfo::Kind::kType, }, { /* [111] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [112] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [113] */ - /* name */ "F", + /* name */ "AM", /* matcher_indices */ MatcherIndicesIndex(3), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [114] */ - /* name */ "RW", - /* matcher_indices */ MatcherIndicesIndex(5), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [115] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [116] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(475), /* kind */ TemplateInfo::Kind::kType, }, { /* [117] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(411), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [118] */ - /* name */ "RW", - /* matcher_indices */ MatcherIndicesIndex(5), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [119] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [120] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [121] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(407), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [122] */ - /* name */ "RW", - /* matcher_indices */ MatcherIndicesIndex(5), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(156), + /* kind */ TemplateInfo::Kind::kType, }, { /* [123] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [124] */ - /* name */ "T", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kType, + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [125] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(501), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [126] */ - /* name */ "AS", - /* matcher_indices */ MatcherIndicesIndex(208), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "Majorness", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kmajorness, }, { /* [127] */ - /* name */ "N", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, }, { /* [128] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(536), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(146), /* kind */ TemplateInfo::Kind::kType, }, { /* [129] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(538), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [130] */ - /* name */ "T", + /* name */ "R", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kType, + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [131] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(5), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AM", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [132] */ - /* name */ "AS", - /* matcher_indices */ MatcherIndicesIndex(8), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kType, }, { /* [133] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [134] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(535), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(423), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [135] */ @@ -9996,836 +6827,1442 @@ constexpr TemplateInfo kTemplates[] = { }, { /* [136] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [137] */ /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(8), - /* kind */ TemplateInfo::Kind::kNumber, + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, }, { /* [138] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(536), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [139] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [140] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [141] */ - /* name */ "R", + /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [142] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(217), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [143] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, }, { /* [144] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(219), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(476), /* kind */ TemplateInfo::Kind::kType, }, { /* [145] */ - /* name */ "M", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kType, }, { /* [146] */ - /* name */ "N", + /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [147] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(536), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [148] */ - /* name */ "N", + /* name */ "K", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [149] */ - /* name */ "M", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(273), + /* kind */ TemplateInfo::Kind::kType, }, { /* [150] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(273), /* kind */ TemplateInfo::Kind::kType, }, { /* [151] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [152] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [153] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [154] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, + { + /* [154] */ + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(477), + /* kind */ TemplateInfo::Kind::kType, + }, { /* [155] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(478), /* kind */ TemplateInfo::Kind::kType, }, { /* [156] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [157] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [158] */ /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [159] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [160] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [161] */ /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [162] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { /* [163] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [164] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(5), /* kind */ TemplateInfo::Kind::kType, }, { /* [165] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(476), /* kind */ TemplateInfo::Kind::kType, }, { /* [166] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [167] */ - /* name */ "C", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [168] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [169] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(479), + /* matcher_indices */ MatcherIndicesIndex(273), /* kind */ TemplateInfo::Kind::kType, }, { /* [170] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(273), /* kind */ TemplateInfo::Kind::kType, }, { /* [171] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [172] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(481), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [173] */ /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [174] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(478), /* kind */ TemplateInfo::Kind::kType, }, { /* [175] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(483), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(477), /* kind */ TemplateInfo::Kind::kType, }, { /* [176] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [177] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [178] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(485), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [179] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [180] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "TR", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [181] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(487), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [182] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [183] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [184] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(489), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [185] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [186] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(423), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [187] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(491), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [188] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(219), + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [189] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [190] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(385), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [191] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [192] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [193] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(388), + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [194] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kType, }, { /* [195] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [196] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(352), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(423), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [197] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, }, { /* [198] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [199] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(391), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [200] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [201] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [202] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(394), + /* name */ "O", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [203] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, }, { /* [204] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [205] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(355), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(270), + /* kind */ TemplateInfo::Kind::ktexel_format, }, { /* [206] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [207] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [208] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(445), + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [209] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(17), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [210] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [210] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(474), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, { /* [211] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [212] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [213] */ - /* name */ "A", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [214] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(536), + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, + { + /* [214] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, { /* [215] */ + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [216] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [217] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [218] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [219] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [220] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [221] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [222] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(270), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [223] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [224] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [225] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [226] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(474), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [227] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [228] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [229] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [230] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [231] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [232] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [233] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [234] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(270), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [235] */ + /* name */ "RW", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [236] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [237] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [238] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(474), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [239] */ + /* name */ "RW", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [240] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [241] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [242] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [243] */ + /* name */ "RW", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [244] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [245] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [246] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [247] */ /* name */ "C", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, - { - /* [216] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [217] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [218] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(33), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [219] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [220] */ - /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [221] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(223), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [222] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [223] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(539), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [224] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [225] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(540), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [226] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [227] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(551), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [228] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(226), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [229] */ - /* name */ "N", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [230] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(555), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [231] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(403), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [232] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [233] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(407), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [234] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [235] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(219), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [236] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [237] */ - /* name */ "K", - /* matcher_indices */ MatcherIndicesIndex(542), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [238] */ - /* name */ "L", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [239] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [240] */ - /* name */ "R", - /* matcher_indices */ MatcherIndicesIndex(501), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [241] */ - /* name */ "F", - /* matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [242] */ - /* name */ "W", - /* matcher_indices */ MatcherIndicesIndex(33), - /* kind */ TemplateInfo::Kind::kNumber, - }, - { - /* [243] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(543), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [244] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [245] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(544), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [246] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [247] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(545), - /* kind */ TemplateInfo::Kind::kType, - }, { /* [248] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, }, { /* [249] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(546), + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [250] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [251] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(547), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(423), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [252] */ /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), + /* matcher_indices */ MatcherIndicesIndex(461), /* kind */ TemplateInfo::Kind::kType, }, { /* [253] */ - /* name */ "S", - /* matcher_indices */ MatcherIndicesIndex(550), + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kType, }, { /* [254] */ - /* name */ "I", - /* matcher_indices */ MatcherIndicesIndex(537), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kaccess, }, { /* [255] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(556), - /* kind */ TemplateInfo::Kind::kType, + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, }, { /* [256] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [257] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(460), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [258] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [259] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [260] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [261] */ + /* name */ "AS", + /* matcher_indices */ MatcherIndicesIndex(423), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [262] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [263] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [264] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(256), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [265] */ /* name */ "N", /* matcher_indices */ MatcherIndicesIndex(/* invalid */), /* kind */ TemplateInfo::Kind::kNumber, }, { - /* [257] */ - /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(20), - /* kind */ TemplateInfo::Kind::kType, - }, - { - /* [258] */ + /* [266] */ /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(559), + /* matcher_indices */ MatcherIndicesIndex(258), /* kind */ TemplateInfo::Kind::kType, }, { - /* [259] */ + /* [267] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [268] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(27), + /* matcher_indices */ MatcherIndicesIndex(460), /* kind */ TemplateInfo::Kind::kType, }, { - /* [260] */ + /* [269] */ /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(560), + /* matcher_indices */ MatcherIndicesIndex(462), /* kind */ TemplateInfo::Kind::kType, }, { - /* [261] */ + /* [270] */ + /* name */ "M", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [271] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [272] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(17), + /* matcher_indices */ MatcherIndicesIndex(460), /* kind */ TemplateInfo::Kind::kType, }, { - /* [262] */ + /* [273] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [274] */ + /* name */ "M", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [275] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [276] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [277] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [278] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [279] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [280] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [281] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [282] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(475), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [283] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [284] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ksubgroup_matrix_kind, + }, + { + /* [285] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [286] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [287] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(385), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [288] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [289] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [290] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(387), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [291] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [292] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [293] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(389), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [294] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [295] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [296] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(391), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [297] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [298] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [299] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(393), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [300] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [301] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [302] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(395), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [303] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [304] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [305] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(397), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [306] */ + /* name */ "K", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [307] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [308] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [309] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [310] */ + /* name */ "A", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [311] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(460), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [312] */ + /* name */ "C", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [313] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [314] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [315] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(459), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [316] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [317] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [318] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(407), + /* kind */ TemplateInfo::Kind::kaddress_space, + }, + { + /* [319] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [320] */ + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [321] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [322] */ /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(557), + /* matcher_indices */ MatcherIndicesIndex(258), /* kind */ TemplateInfo::Kind::kType, }, { - /* [263] */ + /* [323] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(262), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [324] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [325] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(463), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [326] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [327] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(464), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [328] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [329] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(479), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [330] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(265), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [331] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [332] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(319), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [333] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [334] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(323), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [335] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [336] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(258), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [337] */ + /* name */ "L", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [338] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [339] */ + /* name */ "R", + /* matcher_indices */ MatcherIndicesIndex(4), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [340] */ + /* name */ "F", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::ktexel_format, + }, + { + /* [341] */ + /* name */ "W", + /* matcher_indices */ MatcherIndicesIndex(327), + /* kind */ TemplateInfo::Kind::kaccess, + }, + { + /* [342] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(466), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [343] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [344] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(467), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [345] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [346] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(468), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [347] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [348] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(469), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [349] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [350] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(470), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [351] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [352] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(472), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [353] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [354] */ + /* name */ "S", + /* matcher_indices */ MatcherIndicesIndex(473), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [355] */ + /* name */ "I", + /* matcher_indices */ MatcherIndicesIndex(461), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [356] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(480), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [357] */ + /* name */ "N", + /* matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* kind */ TemplateInfo::Kind::kNumber, + }, + { + /* [358] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(273), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [359] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(483), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [360] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(5), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [361] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(484), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [362] */ + /* name */ "T", + /* matcher_indices */ MatcherIndicesIndex(15), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [363] */ + /* name */ "U", + /* matcher_indices */ MatcherIndicesIndex(481), + /* kind */ TemplateInfo::Kind::kType, + }, + { + /* [364] */ /* name */ "T", /* matcher_indices */ MatcherIndicesIndex(4), /* kind */ TemplateInfo::Kind::kType, }, { - /* [264] */ + /* [365] */ /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(558), + /* matcher_indices */ MatcherIndicesIndex(482), /* kind */ TemplateInfo::Kind::kType, }, { - /* [265] */ + /* [366] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(213), + /* matcher_indices */ MatcherIndicesIndex(151), /* kind */ TemplateInfo::Kind::kType, }, { - /* [266] */ + /* [367] */ /* name */ "U", - /* matcher_indices */ MatcherIndicesIndex(561), + /* matcher_indices */ MatcherIndicesIndex(485), /* kind */ TemplateInfo::Kind::kType, }, { - /* [267] */ + /* [368] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(405), + /* matcher_indices */ MatcherIndicesIndex(321), /* kind */ TemplateInfo::Kind::kType, }, { - /* [268] */ + /* [369] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(541), + /* matcher_indices */ MatcherIndicesIndex(465), /* kind */ TemplateInfo::Kind::kType, }, { - /* [269] */ + /* [370] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(557), + /* matcher_indices */ MatcherIndicesIndex(481), /* kind */ TemplateInfo::Kind::kType, }, { - /* [270] */ + /* [371] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(558), + /* matcher_indices */ MatcherIndicesIndex(482), /* kind */ TemplateInfo::Kind::kType, }, { - /* [271] */ + /* [372] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(559), + /* matcher_indices */ MatcherIndicesIndex(483), /* kind */ TemplateInfo::Kind::kType, }, { - /* [272] */ + /* [373] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(560), + /* matcher_indices */ MatcherIndicesIndex(484), /* kind */ TemplateInfo::Kind::kType, }, { - /* [273] */ + /* [374] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(561), + /* matcher_indices */ MatcherIndicesIndex(485), /* kind */ TemplateInfo::Kind::kType, }, { - /* [274] */ + /* [375] */ /* name */ "T", - /* matcher_indices */ MatcherIndicesIndex(552), + /* matcher_indices */ MatcherIndicesIndex(476), /* kind */ TemplateInfo::Kind::kType, }, }; @@ -10956,3468 +8393,3468 @@ static_assert(ConstEvalFunctionIndex::CanIndex(kConstEvalFunctions), constexpr OverloadInfo kOverloads[] = { { /* [0] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(663), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(275), + /* parameters */ ParameterIndex(358), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [1] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(667), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(275), + /* parameters */ ParameterIndex(361), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [2] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(231), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [3] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(675), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(275), + /* parameters */ ParameterIndex(364), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [4] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(679), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(278), + /* parameters */ ParameterIndex(367), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [5] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(276), + /* parameters */ ParameterIndex(370), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [6] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(218), + /* parameters */ ParameterIndex(235), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [7] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(279), + /* parameters */ ParameterIndex(373), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [8] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(204), + /* parameters */ ParameterIndex(436), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [9] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(221), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [10] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(591), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(225), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [11] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(595), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [12] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(599), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(221), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [13] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(603), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(225), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [14] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(607), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [15] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(19), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(221), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [16] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(316), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(225), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [17] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [18] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(326), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(221), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [19] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(47), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(225), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [20] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(311), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [21] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(316), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(221), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [22] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(225), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [23] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(326), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(229), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [24] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(331), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [25] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(150), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [26] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(156), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [27] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [28] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(168), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [29] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(174), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [30] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(611), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [31] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(615), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [32] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(619), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 4, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [33] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(623), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [34] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(627), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [35] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(411), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [36] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(416), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [37] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [38] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(426), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [39] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(659), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(358), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [40] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(180), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(416), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [41] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(631), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(75), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [42] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(418), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [43] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(639), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(27), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [44] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(204), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(420), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [45] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(364), + /* return_matcher_indices */ MatcherIndicesIndex(347), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [46] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(583), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(422), + /* return_matcher_indices */ MatcherIndicesIndex(347), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [47] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(184), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [48] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(296), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(424), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [49] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(703), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(80), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [50] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(516), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 2, + /* templates */ TemplateIndex(336), + /* parameters */ ParameterIndex(426), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [51] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(663), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(367), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [52] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(667), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [53] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(428), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [54] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(675), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [55] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(679), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(430), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [56] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(436), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [57] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(441), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(432), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [58] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(446), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [59] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(451), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(434), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [60] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(456), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* parameters */ ParameterIndex(373), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [61] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(436), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(508), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [62] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(441), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(509), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [63] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(446), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(510), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [64] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(451), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(511), + /* return_matcher_indices */ MatcherIndicesIndex(347), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [65] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(456), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(340), + /* parameters */ ParameterIndex(508), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [66] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(210), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(340), + /* parameters */ ParameterIndex(509), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [67] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(216), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(340), + /* parameters */ ParameterIndex(510), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [68] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(222), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(340), + /* parameters */ ParameterIndex(511), + /* return_matcher_indices */ MatcherIndicesIndex(347), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [69] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(228), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(512), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [70] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(234), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(340), + /* parameters */ ParameterIndex(512), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [71] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(210), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(319), + /* return_matcher_indices */ MatcherIndicesIndex(3), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [72] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(216), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(403), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [73] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(222), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [74] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(228), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [75] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(234), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [76] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(461), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [77] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(466), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [78] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(471), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [79] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(476), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [80] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(481), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(403), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [81] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(461), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(406), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [82] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(466), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(409), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [83] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(471), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [84] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(476), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(483), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [85] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(481), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(485), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [86] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(683), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(403), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [87] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(687), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(406), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [88] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(691), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(409), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [89] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(695), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(481), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [90] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(699), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(483), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [91] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(486), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(485), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [92] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(491), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(358), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [93] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(496), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(360), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [94] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(501), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(362), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [95] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(506), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(364), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [96] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(366), + /* parameters */ ParameterIndex(522), + /* return_matcher_indices */ MatcherIndicesIndex(357), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [97] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(401), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [98] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [99] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [100] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(703), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [101] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(516), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [102] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [103] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(235), - /* parameters */ ParameterIndex(869), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [104] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(247), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [105] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(235), - /* parameters */ ParameterIndex(871), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(403), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [106] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(55), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(406), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [107] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(235), - /* parameters */ ParameterIndex(873), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(403), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [108] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(431), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(406), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(111), }, { /* [109] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(235), - /* parameters */ ParameterIndex(875), - /* return_matcher_indices */ MatcherIndicesIndex(431), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(358), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [110] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(564), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(360), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [111] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(235), - /* parameters */ ParameterIndex(877), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(362), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [112] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(272), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(364), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [113] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(235), - /* parameters */ ParameterIndex(879), - /* return_matcher_indices */ MatcherIndicesIndex(3), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(366), + /* parameters */ ParameterIndex(521), + /* return_matcher_indices */ MatcherIndicesIndex(327), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [114] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(207), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [115] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(881), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [116] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(195), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [117] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(883), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(19), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [118] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(99), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [119] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(885), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(50), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [120] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(431), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(199), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [121] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(887), - /* return_matcher_indices */ MatcherIndicesIndex(431), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(119), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [122] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(56), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [123] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(889), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [124] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(187), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [125] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(891), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [126] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(84), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [127] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* parameters */ ParameterIndex(215), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [128] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(893), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [129] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* parameters */ ParameterIndex(207), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [130] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(895), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(124), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [131] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* parameters */ ParameterIndex(124), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [132] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(897), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(62), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [133] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(62), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [134] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(21), - /* parameters */ ParameterIndex(899), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(129), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [135] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* parameters */ ParameterIndex(129), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [136] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(239), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(211), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [137] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(239), - /* parameters */ ParameterIndex(980), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(134), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [138] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(239), - /* parameters */ ParameterIndex(981), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 1, + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [139] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(239), - /* parameters */ ParameterIndex(982), - /* return_matcher_indices */ MatcherIndicesIndex(431), + /* num_templates */ 1, + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [140] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(241), - /* parameters */ ParameterIndex(979), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [141] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(241), - /* parameters */ ParameterIndex(980), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [142] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(241), - /* parameters */ ParameterIndex(981), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 1, + /* templates */ TemplateIndex(208), + /* parameters */ ParameterIndex(215), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [143] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(241), - /* parameters */ ParameterIndex(982), - /* return_matcher_indices */ MatcherIndicesIndex(431), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(273), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [144] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(239), - /* parameters */ ParameterIndex(983), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 3, + /* templates */ TemplateIndex(204), + /* parameters */ ParameterIndex(322), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [145] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(241), - /* parameters */ ParameterIndex(983), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 3, + /* templates */ TemplateIndex(204), + /* parameters */ ParameterIndex(325), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [146] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(787), - /* return_matcher_indices */ MatcherIndicesIndex(3), + /* num_templates */ 4, + /* templates */ TemplateIndex(204), + /* parameters */ ParameterIndex(219), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [147] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(163), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* templates */ TemplateIndex(204), + /* parameters */ ParameterIndex(328), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [148] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(163), - /* parameters */ ParameterIndex(829), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* templates */ TemplateIndex(233), + /* parameters */ ParameterIndex(331), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [149] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(719), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* num_templates */ 3, + /* templates */ TemplateIndex(209), + /* parameters */ ParameterIndex(334), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [150] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(163), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* templates */ TemplateIndex(209), + /* parameters */ ParameterIndex(337), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [151] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(835), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* templates */ TemplateIndex(209), + /* parameters */ ParameterIndex(223), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [152] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(838), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* num_templates */ 3, + /* templates */ TemplateIndex(209), + /* parameters */ ParameterIndex(340), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [153] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(723), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* num_templates */ 3, + /* templates */ TemplateIndex(237), + /* parameters */ ParameterIndex(343), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [154] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(96), - /* parameters */ ParameterIndex(841), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* num_templates */ 3, + /* templates */ TemplateIndex(213), + /* parameters */ ParameterIndex(346), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [155] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(166), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* templates */ TemplateIndex(213), + /* parameters */ ParameterIndex(349), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [156] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(97), - /* parameters */ ParameterIndex(847), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 4, + /* templates */ TemplateIndex(213), + /* parameters */ ParameterIndex(227), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [157] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(19), - /* parameters */ ParameterIndex(727), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* templates */ TemplateIndex(213), + /* parameters */ ParameterIndex(352), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [158] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(155), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* num_templates */ 3, + /* templates */ TemplateIndex(241), + /* parameters */ ParameterIndex(355), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [159] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(19), - /* parameters */ ParameterIndex(901), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(287), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [160] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(290), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [161] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* templates */ TemplateIndex(293), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [162] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* templates */ TemplateIndex(296), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [163] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(299), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [164] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* templates */ TemplateIndex(302), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [165] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* templates */ TemplateIndex(305), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [166] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(342), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [167] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(344), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [168] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(346), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [169] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(348), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [170] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(350), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [171] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(352), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [172] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(100), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(354), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [173] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(104), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* templates */ TemplateIndex(287), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [174] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(108), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* templates */ TemplateIndex(290), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [175] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(293), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [176] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* templates */ TemplateIndex(296), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [177] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* templates */ TemplateIndex(299), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [178] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(302), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [179] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 3, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* templates */ TemplateIndex(305), + /* parameters */ ParameterIndex(516), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [180] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(342), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [181] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(344), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [182] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(346), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [183] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(348), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [184] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(350), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [185] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(352), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [186] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(354), + /* parameters */ ParameterIndex(517), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [187] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(399), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [188] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(421), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [189] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(423), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [190] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(336), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [191] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(341), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [192] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(109), }, { /* [193] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(351), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [194] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(356), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(287), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(110), }, { /* [195] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(336), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(358), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [196] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(341), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(360), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [197] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(346), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(362), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [198] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(351), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(364), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [199] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(356), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(366), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(377), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [200] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(90), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(74), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [201] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(96), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(74), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [202] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(102), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(26), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [203] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(108), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(26), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [204] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(114), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(183), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [205] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(90), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 3, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(79), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [206] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(96), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(139), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [207] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(102), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(187), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [208] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(108), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(68), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [209] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(114), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(84), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [210] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(361), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* parameters */ ParameterIndex(215), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [211] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(366), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(144), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [212] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(371), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(96), + /* parameters */ ParameterIndex(239), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [213] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(376), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(27), + /* parameters */ ParameterIndex(243), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [214] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(381), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(102), + /* parameters */ ParameterIndex(247), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [215] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(361), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(108), + /* parameters */ ParameterIndex(251), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [216] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(366), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(35), + /* parameters */ ParameterIndex(255), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [217] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(371), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(43), + /* parameters */ ParameterIndex(259), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [218] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 7, + /* templates */ TemplateIndex(75), /* parameters */ ParameterIndex(376), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [219] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(381), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 9, + /* templates */ TemplateIndex(0), + /* parameters */ ParameterIndex(379), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [220] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(643), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 7, + /* templates */ TemplateIndex(82), + /* parameters */ ParameterIndex(382), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [221] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(647), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 7, + /* templates */ TemplateIndex(89), + /* parameters */ ParameterIndex(385), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [222] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(651), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 9, + /* templates */ TemplateIndex(9), + /* parameters */ ParameterIndex(388), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [223] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(655), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 2, + /* num_templates */ 9, + /* templates */ TemplateIndex(18), + /* parameters */ ParameterIndex(391), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [224] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(659), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 5, + /* templates */ TemplateIndex(115), + /* parameters */ ParameterIndex(149), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [225] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(386), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 7, + /* templates */ TemplateIndex(52), + /* parameters */ ParameterIndex(154), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [226] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(391), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 5, + /* templates */ TemplateIndex(121), + /* parameters */ ParameterIndex(159), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [227] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(396), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 5, + /* templates */ TemplateIndex(127), + /* parameters */ ParameterIndex(164), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [228] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(401), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 7, + /* templates */ TemplateIndex(60), + /* parameters */ ParameterIndex(169), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [229] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(406), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 7, + /* templates */ TemplateIndex(68), + /* parameters */ ParameterIndex(174), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [230] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(114), + /* parameters */ ParameterIndex(263), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [231] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(51), + /* parameters */ ParameterIndex(267), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [232] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(120), + /* parameters */ ParameterIndex(271), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [233] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(126), + /* parameters */ ParameterIndex(275), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [234] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(59), + /* parameters */ ParameterIndex(279), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [235] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 8, + /* templates */ TemplateIndex(67), + /* parameters */ ParameterIndex(283), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [236] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(490), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [237] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(364), + /* parameters */ ParameterIndex(491), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [238] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(492), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [239] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(368), + /* parameters */ ParameterIndex(493), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [240] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(19), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(321), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [241] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(26), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 3, + /* templates */ TemplateIndex(264), + /* parameters */ ParameterIndex(494), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [242] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(33), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(323), + /* parameters */ ParameterIndex(495), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [243] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(40), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(330), + /* parameters */ ParameterIndex(496), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [244] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(47), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(332), + /* parameters */ ParameterIndex(311), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [245] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(19), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 2, + /* templates */ TemplateIndex(334), + /* parameters */ ParameterIndex(497), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(10), }, { /* [246] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(26), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(358), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [247] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(33), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(75), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [248] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(40), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(27), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [249] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 7, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(47), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(364), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [250] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(150), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(184), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [251] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(156), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(80), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [252] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [253] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(168), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [254] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(174), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [255] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(150), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [256] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(156), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [257] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [258] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(168), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [259] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(174), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(469), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [260] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(411), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(272), + /* parameters */ ParameterIndex(474), + /* return_matcher_indices */ MatcherIndicesIndex(231), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [261] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(416), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(272), + /* parameters */ ParameterIndex(473), + /* return_matcher_indices */ MatcherIndicesIndex(231), + /* const_eval_fn */ ConstEvalFunctionIndex(87), }, { /* [262] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(311), + /* parameters */ ParameterIndex(475), + /* return_matcher_indices */ MatcherIndicesIndex(313), + /* const_eval_fn */ ConstEvalFunctionIndex(88), }, { /* [263] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(426), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(311), + /* parameters */ ParameterIndex(477), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(89), }, { /* [264] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(431), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 4, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(479), + /* return_matcher_indices */ MatcherIndicesIndex(235), + /* const_eval_fn */ ConstEvalFunctionIndex(90), }, { /* [265] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(180), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [266] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(186), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(523), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [267] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(25), - /* parameters */ ParameterIndex(192), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(523), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [268] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(23), - /* parameters */ ParameterIndex(198), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [269] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(204), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [270] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(246), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [271] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(251), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [272] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(153), - /* parameters */ ParameterIndex(555), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(524), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [273] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(559), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(525), + /* return_matcher_indices */ MatcherIndicesIndex(407), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [274] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(266), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [275] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(246), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [276] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(251), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(526), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [277] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(160), - /* parameters */ ParameterIndex(256), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [278] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(261), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [279] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(266), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [280] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(54), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [281] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(60), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(527), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [282] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(66), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(528), + /* return_matcher_indices */ MatcherIndicesIndex(413), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [283] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(72), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [284] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(78), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [285] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(54), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(529), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [286] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(60), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 8, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [287] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 8, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(66), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [288] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(72), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [289] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(78), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [290] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(563), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(530), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [291] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, /* templates */ TemplateIndex(150), - /* parameters */ ParameterIndex(567), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* parameters */ ParameterIndex(531), + /* return_matcher_indices */ MatcherIndicesIndex(208), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [292] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(153), - /* parameters */ ParameterIndex(571), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [293] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(157), - /* parameters */ ParameterIndex(575), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(532), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [294] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(579), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(532), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [295] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(271), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [296] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(276), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [297] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(76), - /* parameters */ ParameterIndex(281), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [298] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(72), - /* parameters */ ParameterIndex(286), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(291), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [299] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(291), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(533), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [300] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(511), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(534), + /* return_matcher_indices */ MatcherIndicesIndex(423), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [301] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(583), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [302] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(240), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(535), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [303] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(296), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(535), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [304] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(703), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 9, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [305] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 9, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(516), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [306] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(497), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [307] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, + /* num_parameters */ 3, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [308] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(536), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [309] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(537), + /* return_matcher_indices */ MatcherIndicesIndex(429), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [310] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 0, /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [311] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 0, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(538), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [312] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(538), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [313] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, + /* num_parameters */ 12, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [314] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* num_parameters */ 12, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(856), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [315] */ @@ -14425,129 +11862,129 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 3, /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(859), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [316] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(862), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [317] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(954), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(539), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [318] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(956), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(540), + /* return_matcher_indices */ MatcherIndicesIndex(435), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [319] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 0, /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(958), + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [320] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, + /* num_parameters */ 1, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(856), + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(541), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [321] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(859), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(541), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [322] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, + /* num_parameters */ 8, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(862), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [323] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 8, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(954), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [324] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, + /* num_parameters */ 4, + /* num_explicit_templates */ 1, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(956), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(291), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [325] */ /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 4, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(958), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(291), /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [326] */ /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(257), - /* parameters */ ParameterIndex(993), + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(542), /* return_matcher_indices */ MatcherIndicesIndex(441), /* const_eval_fn */ ConstEvalFunctionIndex(108), }, @@ -14556,2266 +11993,2266 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(259), - /* parameters */ ParameterIndex(993), + /* num_templates */ 1, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(543), /* return_matcher_indices */ MatcherIndicesIndex(441), /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [328] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(261), - /* parameters */ ParameterIndex(993), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [329] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(263), - /* parameters */ ParameterIndex(993), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(544), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [330] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(265), - /* parameters */ ParameterIndex(993), - /* return_matcher_indices */ MatcherIndicesIndex(441), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(544), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [331] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 12, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(169), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [332] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(172), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 12, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [333] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(175), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [334] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [335] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(545), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [336] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(184), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(546), + /* return_matcher_indices */ MatcherIndicesIndex(447), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [337] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(187), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(106), }, { /* [338] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(243), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(375), + /* parameters */ ParameterIndex(547), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [339] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(245), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(547), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(107), }, { /* [340] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 16, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(247), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [341] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(249), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 16, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(112), }, { /* [342] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(251), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [343] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(253), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(299), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(113), }, { /* [344] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(190), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(145), + /* parameters */ ParameterIndex(548), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [345] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(193), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(150), + /* parameters */ ParameterIndex(549), + /* return_matcher_indices */ MatcherIndicesIndex(453), + /* const_eval_fn */ ConstEvalFunctionIndex(108), }, { /* [346] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(196), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(104), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [347] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(199), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(104), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [348] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(202), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(38), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [349] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(205), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(38), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [350] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(208), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(109), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [351] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(169), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(109), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [352] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(172), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(203), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [353] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(175), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(114), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [354] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(178), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [355] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(181), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [356] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(184), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(19), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [357] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(187), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 7, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(19), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [358] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(243), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(50), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [359] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(245), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(50), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [360] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(247), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(119), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [361] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(249), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(56), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [362] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(251), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [363] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(253), - /* parameters */ ParameterIndex(988), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [364] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(190), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [365] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(193), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [366] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(196), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [367] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(199), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [368] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(202), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(27), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [369] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(205), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(80), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [370] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(208), - /* parameters */ ParameterIndex(987), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [371] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(495), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [372] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(338), + /* parameters */ ParameterIndex(510), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [373] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(340), + /* parameters */ ParameterIndex(510), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [374] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [375] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [376] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(109), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [377] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [378] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(110), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [379] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(856), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [380] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(859), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [381] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(856), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(89), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [382] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(859), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(111), + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [383] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(257), - /* parameters */ ParameterIndex(992), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 6, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(32), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [384] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(259), - /* parameters */ ParameterIndex(992), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(191), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [385] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(261), - /* parameters */ ParameterIndex(992), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 5, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(207), + /* parameters */ ParameterIndex(94), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [386] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(263), - /* parameters */ ParameterIndex(992), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(85), }, { /* [387] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(265), - /* parameters */ ParameterIndex(992), - /* return_matcher_indices */ MatcherIndicesIndex(411), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(85), }, { /* [388] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(826), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(85), }, { /* [389] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(247), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(469), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(85), }, { /* [390] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(55), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(272), + /* parameters */ ParameterIndex(472), + /* return_matcher_indices */ MatcherIndicesIndex(231), + /* const_eval_fn */ ConstEvalFunctionIndex(85), }, { /* [391] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(832), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [392] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(564), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [393] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(272), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [394] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(671), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(469), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [395] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 3, + /* templates */ TemplateIndex(272), + /* parameters */ ParameterIndex(472), + /* return_matcher_indices */ MatcherIndicesIndex(231), + /* const_eval_fn */ ConstEvalFunctionIndex(86), }, { /* [396] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(144), + /* parameters */ ParameterIndex(460), + /* return_matcher_indices */ MatcherIndicesIndex(145), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [397] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(162), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(149), + /* parameters */ ParameterIndex(460), + /* return_matcher_indices */ MatcherIndicesIndex(145), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [398] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(421), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(154), + /* parameters */ ParameterIndex(460), + /* return_matcher_indices */ MatcherIndicesIndex(145), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [399] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(237), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(159), + /* parameters */ ParameterIndex(460), + /* return_matcher_indices */ MatcherIndicesIndex(145), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [400] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 5, + /* templates */ TemplateIndex(164), + /* parameters */ ParameterIndex(394), + /* return_matcher_indices */ MatcherIndicesIndex(160), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [401] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 5, + /* templates */ TemplateIndex(169), + /* parameters */ ParameterIndex(394), + /* return_matcher_indices */ MatcherIndicesIndex(160), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [402] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(4), + /* num_templates */ 5, + /* templates */ TemplateIndex(174), + /* parameters */ ParameterIndex(394), + /* return_matcher_indices */ MatcherIndicesIndex(160), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [403] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 5, + /* templates */ TemplateIndex(179), + /* parameters */ ParameterIndex(394), + /* return_matcher_indices */ MatcherIndicesIndex(160), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [404] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(184), + /* parameters */ ParameterIndex(397), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [405] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(189), + /* parameters */ ParameterIndex(397), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [406] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(249), + /* parameters */ ParameterIndex(400), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [407] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 1, + /* num_templates */ 4, + /* templates */ TemplateIndex(253), + /* parameters */ ParameterIndex(400), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [408] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(132), + /* parameters */ ParameterIndex(397), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [409] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 6, + /* templates */ TemplateIndex(138), + /* parameters */ ParameterIndex(397), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [410] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(194), + /* parameters */ ParameterIndex(400), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [411] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 1, + /* num_templates */ 5, + /* templates */ TemplateIndex(199), + /* parameters */ ParameterIndex(400), + /* return_matcher_indices */ MatcherIndicesIndex(211), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [412] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(133), + /* parameters */ ParameterIndex(514), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [413] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(139), + /* parameters */ ParameterIndex(514), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [414] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(133), + /* parameters */ ParameterIndex(515), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [415] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(139), + /* parameters */ ParameterIndex(515), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [416] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(91), + }, + { + /* [417] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(91), + }, + { + /* [418] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(91), + }, + { + /* [419] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(469), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(91), + }, + { + /* [420] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(92), + }, + { + /* [421] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(92), + }, + { + /* [422] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(468), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(92), + }, + { + /* [423] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(469), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(92), + }, + { + /* [424] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(94), + }, + { + /* [425] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(250), + /* const_eval_fn */ ConstEvalFunctionIndex(94), + }, + { + /* [426] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(94), + }, + { + /* [427] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(94), + }, + { + /* [428] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(95), + }, + { + /* [429] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(250), + /* const_eval_fn */ ConstEvalFunctionIndex(95), + }, + { + /* [430] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(95), + }, + { + /* [431] */ + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(95), + }, + { + /* [432] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(261), + /* parameters */ ParameterIndex(487), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [433] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(319), + /* parameters */ ParameterIndex(488), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [434] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(319), + /* parameters */ ParameterIndex(489), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [435] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(43), + }, + { + /* [436] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(308), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(43), + }, + { + /* [437] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(309), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(43), + }, + { + /* [438] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(312), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(63), + }, + { + /* [439] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(304), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(63), + }, + { + /* [440] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(324), + /* parameters */ ParameterIndex(315), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(64), + }, + { + /* [441] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 4, + /* templates */ TemplateIndex(245), + /* parameters */ ParameterIndex(462), + /* return_matcher_indices */ MatcherIndicesIndex(130), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [442] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(284), + /* parameters */ ParameterIndex(464), + /* return_matcher_indices */ MatcherIndicesIndex(175), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [443] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(284), + /* parameters */ ParameterIndex(466), + /* return_matcher_indices */ MatcherIndicesIndex(180), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [444] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(106), + }, + { + /* [445] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(520), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(107), + }, + { + /* [446] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(370), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(15), + /* const_eval_fn */ ConstEvalFunctionIndex(108), + }, + { + /* [447] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(106), + }, + { + /* [448] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(107), + }, + { + /* [449] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(371), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(4), + /* const_eval_fn */ ConstEvalFunctionIndex(108), + }, + { + /* [450] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(106), + }, + { + /* [451] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(499), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(107), + }, + { + /* [452] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(372), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(108), + }, + { + /* [453] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(5), + /* const_eval_fn */ ConstEvalFunctionIndex(106), + }, + { + /* [454] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(490), + /* return_matcher_indices */ MatcherIndicesIndex(5), + /* const_eval_fn */ ConstEvalFunctionIndex(107), + }, + { + /* [455] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(373), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(5), + /* const_eval_fn */ ConstEvalFunctionIndex(108), + }, + { + /* [456] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 0, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(/* invalid */), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(106), + }, + { + /* [457] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(107), + }, + { + /* [458] */ + /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(374), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(108), + }, + { + /* [459] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(0), + }, + { + /* [460] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(314), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(0), + }, + { + /* [461] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(1), + }, + { + /* [462] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(1), + }, + { + /* [463] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(2), + }, + { + /* [464] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(2), + }, + { + /* [465] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [404] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(80), - /* parameters */ ParameterIndex(790), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [405] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(80), - /* parameters */ ParameterIndex(793), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [406] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(80), - /* parameters */ ParameterIndex(707), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [407] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(80), - /* parameters */ ParameterIndex(796), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [408] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(112), - /* parameters */ ParameterIndex(799), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [409] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(802), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [410] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(805), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [411] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(711), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [412] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(84), - /* parameters */ ParameterIndex(808), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [413] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(116), - /* parameters */ ParameterIndex(811), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [414] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(814), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [415] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(817), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [416] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(715), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [417] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(88), - /* parameters */ ParameterIndex(820), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [418] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(120), - /* parameters */ ParameterIndex(823), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [419] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(493), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [420] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [421] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [422] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [423] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(109), - }, - { - /* [424] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(109), - }, - { - /* [425] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(110), - }, - { - /* [426] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(755), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(110), - }, - { - /* [427] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(257), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [428] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(259), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [429] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(261), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [430] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(263), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [431] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(265), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(471), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [432] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(961), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [433] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(263), - /* parameters */ ParameterIndex(962), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [434] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(963), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [435] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(267), - /* parameters */ ParameterIndex(964), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [436] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(219), - /* parameters */ ParameterIndex(779), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [437] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(142), - /* parameters */ ParameterIndex(965), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [438] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(221), - /* parameters */ ParameterIndex(966), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [439] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(228), - /* parameters */ ParameterIndex(967), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [440] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(231), - /* parameters */ ParameterIndex(779), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [441] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 2, - /* templates */ TemplateIndex(233), - /* parameters */ ParameterIndex(968), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(10), - }, - { - /* [442] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(87), - }, - { - /* [443] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(87), - }, - { - /* [444] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(87), - }, - { - /* [445] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(942), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(87), - }, - { - /* [446] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(147), - /* parameters */ ParameterIndex(947), - /* return_matcher_indices */ MatcherIndicesIndex(192), - /* const_eval_fn */ ConstEvalFunctionIndex(87), - }, - { - /* [447] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(147), - /* parameters */ ParameterIndex(946), - /* return_matcher_indices */ MatcherIndicesIndex(192), - /* const_eval_fn */ ConstEvalFunctionIndex(87), - }, - { - /* [448] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(214), - /* parameters */ ParameterIndex(948), - /* return_matcher_indices */ MatcherIndicesIndex(397), - /* const_eval_fn */ ConstEvalFunctionIndex(88), - }, - { - /* [449] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(214), - /* parameters */ ParameterIndex(950), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(89), - }, - { - /* [450] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(138), - /* parameters */ ParameterIndex(952), - /* return_matcher_indices */ MatcherIndicesIndex(196), - /* const_eval_fn */ ConstEvalFunctionIndex(90), - }, - { - /* [451] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [452] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(994), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [453] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(994), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [454] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(112), - }, - { - /* [455] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(112), - }, - { - /* [456] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(113), - }, - { - /* [457] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(113), - }, - { - /* [458] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(995), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [459] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(996), - /* return_matcher_indices */ MatcherIndicesIndex(501), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [460] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [461] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(997), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [462] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(997), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [463] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(112), - }, - { - /* [464] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(112), - }, - { - /* [465] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(3), }, { /* [466] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(3), }, { /* [467] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(998), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(4), }, { /* [468] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(999), - /* return_matcher_indices */ MatcherIndicesIndex(507), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(4), }, { /* [469] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(5), }, { /* [470] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1000), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(5), }, { /* [471] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1000), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(6), }, { /* [472] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 8, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(6), }, { /* [473] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 8, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), + /* templates */ TemplateIndex(257), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(7), }, { /* [474] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(7), }, { /* [475] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(8), }, { /* [476] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1001), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(272), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(8), }, { /* [477] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1002), - /* return_matcher_indices */ MatcherIndicesIndex(5), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(9), }, { /* [478] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(9), }, { /* [479] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1003), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(11), }, { /* [480] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1003), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(11), }, { /* [481] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), + /* templates */ TemplateIndex(315), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(12), }, { /* [482] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(12), }, { /* [483] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(13), }, { /* [484] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(13), }, { /* [485] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1004), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(14), }, { /* [486] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1005), - /* return_matcher_indices */ MatcherIndicesIndex(12), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(14), }, { /* [487] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(15), }, { /* [488] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1006), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(15), }, { /* [489] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1006), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(16), }, { /* [490] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 9, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(16), }, { /* [491] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 9, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), + /* templates */ TemplateIndex(160), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(17), }, { /* [492] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(17), }, { /* [493] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(19), }, { /* [494] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1007), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(19), }, { /* [495] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1008), - /* return_matcher_indices */ MatcherIndicesIndex(33), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(21), }, { /* [496] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(45), + /* const_eval_fn */ ConstEvalFunctionIndex(21), }, { /* [497] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1009), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(499), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [498] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1009), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(500), + /* return_matcher_indices */ MatcherIndicesIndex(271), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [499] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 12, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), + /* templates */ TemplateIndex(257), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(25), }, { /* [500] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 12, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(25), }, { /* [501] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(26), }, { /* [502] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(26), }, { /* [503] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1010), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(16), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(27), }, { /* [504] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1011), - /* return_matcher_indices */ MatcherIndicesIndex(513), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(180), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(27), }, { /* [505] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(29), }, { /* [506] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1012), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(29), }, { /* [507] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1012), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(30), }, { /* [508] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 8, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(30), }, { /* [509] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 8, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), + /* templates */ TemplateIndex(257), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(31), }, { /* [510] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(31), }, { /* [511] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(759), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(32), }, { /* [512] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1013), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(308), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(32), }, { /* [513] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1014), - /* return_matcher_indices */ MatcherIndicesIndex(519), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(33), }, { /* [514] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(33), }, { /* [515] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1015), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(329), + /* const_eval_fn */ ConstEvalFunctionIndex(34), }, { /* [516] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1015), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(274), + /* const_eval_fn */ ConstEvalFunctionIndex(34), }, { /* [517] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 12, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(15), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(35), }, { /* [518] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 12, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 4, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(35), }, { /* [519] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(36), }, { /* [520] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(36), }, { /* [521] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1016), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(268), + /* parameters */ ParameterIndex(412), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(37), }, { /* [522] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1017), - /* return_matcher_indices */ MatcherIndicesIndex(525), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(414), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(37), }, { /* [523] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(106), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(38), }, { /* [524] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(274), - /* parameters */ ParameterIndex(1018), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(45), + /* const_eval_fn */ ConstEvalFunctionIndex(38), }, { /* [525] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1018), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(107), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(39), }, { /* [526] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 16, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(39), }, { /* [527] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 16, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), + /* templates */ TemplateIndex(257), /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(112), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(40), }, { /* [528] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(40), }, { /* [529] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(767), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(113), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(41), }, { /* [530] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, - /* num_templates */ 1, - /* templates */ TemplateIndex(28), - /* parameters */ ParameterIndex(1019), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(314), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(41), }, { /* [531] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(18), - /* parameters */ ParameterIndex(1020), - /* return_matcher_indices */ MatcherIndicesIndex(169), - /* const_eval_fn */ ConstEvalFunctionIndex(108), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(42), }, { /* [532] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(55), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(314), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(42), }, { /* [533] */ @@ -16823,43 +14260,43 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(272), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(331), + /* const_eval_fn */ ConstEvalFunctionIndex(44), }, { /* [534] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(321), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(280), + /* const_eval_fn */ ConstEvalFunctionIndex(44), }, { /* [535] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(635), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(55), }, { /* [536] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(55), }, { /* [537] */ @@ -16868,349 +14305,349 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* parameters */ ParameterIndex(499), + /* return_matcher_indices */ MatcherIndicesIndex(273), + /* const_eval_fn */ ConstEvalFunctionIndex(56), }, { /* [538] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(239), - /* parameters */ ParameterIndex(981), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(500), + /* return_matcher_indices */ MatcherIndicesIndex(271), + /* const_eval_fn */ ConstEvalFunctionIndex(56), }, { /* [539] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(241), - /* parameters */ ParameterIndex(981), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(57), }, { /* [540] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(933), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(57), }, { /* [541] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(935), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(60), }, { /* [542] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(130), - /* parameters */ ParameterIndex(933), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(60), }, { /* [543] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 4, - /* templates */ TemplateIndex(130), - /* parameters */ ParameterIndex(935), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(61), }, { /* [544] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(61), }, { /* [545] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(939), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(62), }, { /* [546] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(130), - /* parameters */ ParameterIndex(937), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(272), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(62), }, { /* [547] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 3, - /* templates */ TemplateIndex(130), - /* parameters */ ParameterIndex(939), - /* return_matcher_indices */ MatcherIndicesIndex(172), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(327), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(65), }, { /* [548] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(326), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(65), }, { /* [549] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(66), }, { /* [550] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(66), }, { /* [551] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(67), }, { /* [552] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(67), }, { /* [553] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(419), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(68), }, { /* [554] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(308), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(68), }, { /* [555] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(69), }, { /* [556] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(69), }, { /* [557] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(70), }, { /* [558] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(70), }, { /* [559] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(71), }, { /* [560] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(71), }, { /* [561] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(301), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(72), }, { /* [562] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(72), }, { /* [563] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 6, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(84), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(74), }, { /* [564] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(587), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(74), }, { /* [565] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(20), - /* parameters */ ParameterIndex(306), - /* return_matcher_indices */ MatcherIndicesIndex(20), + /* templates */ TemplateIndex(369), + /* parameters */ ParameterIndex(506), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [566] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(120), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 1, + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(507), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [567] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(126), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(367), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [568] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(22), - /* parameters */ ParameterIndex(132), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(373), + /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -17218,10 +14655,10 @@ constexpr OverloadInfo kOverloads[] = { /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(24), - /* parameters */ ParameterIndex(138), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(44), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { @@ -17231,416 +14668,416 @@ constexpr OverloadInfo kOverloads[] = { /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(144), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* parameters */ ParameterIndex(319), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [571] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(787), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* num_templates */ 2, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(440), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [572] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(0), - /* parameters */ ParameterIndex(731), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(442), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [573] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(0), - /* parameters */ ParameterIndex(735), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(246), + /* parameters */ ParameterIndex(440), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [574] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(6), - /* parameters */ ParameterIndex(739), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(442), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [575] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(743), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(444), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [576] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(6), - /* parameters */ ParameterIndex(747), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 3, + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(446), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [577] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 1, - /* num_templates */ 6, - /* templates */ TemplateIndex(12), - /* parameters */ ParameterIndex(751), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(246), + /* parameters */ ParameterIndex(448), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [578] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(1), - /* parameters */ ParameterIndex(521), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(450), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [579] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(1), - /* parameters */ ParameterIndex(526), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(246), + /* parameters */ ParameterIndex(452), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [580] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(531), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(454), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [581] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(13), - /* parameters */ ParameterIndex(536), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(160), + /* parameters */ ParameterIndex(440), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [582] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(7), - /* parameters */ ParameterIndex(541), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(316), + /* parameters */ ParameterIndex(442), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [583] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 5, + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(13), - /* parameters */ ParameterIndex(546), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(282), + /* parameters */ ParameterIndex(456), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [584] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(85), - }, - { - /* [585] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(85), - }, - { - /* [586] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(85), - }, - { - /* [587] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(942), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(85), - }, - { - /* [588] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(147), - /* parameters */ ParameterIndex(945), - /* return_matcher_indices */ MatcherIndicesIndex(192), - /* const_eval_fn */ ConstEvalFunctionIndex(85), + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(458), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [585] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(246), + /* parameters */ ParameterIndex(456), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [586] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(281), + /* parameters */ ParameterIndex(458), + /* return_matcher_indices */ MatcherIndicesIndex(247), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [587] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(329), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + }, + { + /* [588] */ + /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(328), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), + /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { /* [589] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 0, + /* templates */ TemplateIndex(/* invalid */), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(82), }, { /* [590] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 1, + /* templates */ TemplateIndex(135), + /* parameters */ ParameterIndex(317), + /* return_matcher_indices */ MatcherIndicesIndex(250), + /* const_eval_fn */ ConstEvalFunctionIndex(82), }, { /* [591] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 1, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(83), }, { /* [592] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(942), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(83), }, { /* [593] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, + /* num_parameters */ 1, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(147), - /* parameters */ ParameterIndex(945), - /* return_matcher_indices */ MatcherIndicesIndex(192), - /* const_eval_fn */ ConstEvalFunctionIndex(86), + /* num_templates */ 1, + /* templates */ TemplateIndex(327), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(84), }, { /* [594] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(27), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(106), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 1, + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(327), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(84), }, { /* [595] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(35), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(106), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(93), }, { /* [596] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(42), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(106), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 0, + /* num_templates */ 2, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(93), }, { /* [597] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, - /* num_explicit_templates */ 1, - /* num_templates */ 5, - /* templates */ TemplateIndex(47), - /* parameters */ ParameterIndex(925), - /* return_matcher_indices */ MatcherIndicesIndex(106), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_explicit_templates */ 0, + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(98), }, { /* [598] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(52), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(121), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(316), + /* const_eval_fn */ ConstEvalFunctionIndex(98), }, { /* [599] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(57), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(121), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(99), }, { /* [600] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(62), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(121), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(325), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(316), + /* const_eval_fn */ ConstEvalFunctionIndex(99), }, { /* [601] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 5, - /* templates */ TemplateIndex(67), - /* parameters */ ParameterIndex(853), - /* return_matcher_indices */ MatcherIndicesIndex(121), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(100), }, { /* [602] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(125), - /* parameters */ ParameterIndex(985), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(316), + /* const_eval_fn */ ConstEvalFunctionIndex(100), }, { /* [603] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(131), - /* parameters */ ParameterIndex(985), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(101), }, { /* [604] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(125), - /* parameters */ ParameterIndex(986), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(316), + /* const_eval_fn */ ConstEvalFunctionIndex(101), }, { /* [605] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, + /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), + /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(131), - /* parameters */ ParameterIndex(986), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(102), }, { /* [606] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* num_templates */ 2, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(316), + /* const_eval_fn */ ConstEvalFunctionIndex(102), }, { /* [607] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* num_templates */ 1, + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(1), + /* return_matcher_indices */ MatcherIndicesIndex(151), + /* const_eval_fn */ ConstEvalFunctionIndex(103), }, { /* [608] */ @@ -17648,43 +15085,43 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* templates */ TemplateIndex(315), + /* parameters */ ParameterIndex(303), + /* return_matcher_indices */ MatcherIndicesIndex(316), + /* const_eval_fn */ ConstEvalFunctionIndex(103), }, { /* [609] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(942), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(91), + /* num_templates */ 1, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(16), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(104), }, { /* [610] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(92), + /* num_templates */ 2, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(470), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(104), }, { /* [611] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(92), + /* num_templates */ 1, + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(16), + /* return_matcher_indices */ MatcherIndicesIndex(61), + /* const_eval_fn */ ConstEvalFunctionIndex(105), }, { /* [612] */ @@ -17692,2114 +15129,57 @@ constexpr OverloadInfo kOverloads[] = { /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(941), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(92), + /* templates */ TemplateIndex(356), + /* parameters */ ParameterIndex(470), + /* return_matcher_indices */ MatcherIndicesIndex(253), + /* const_eval_fn */ ConstEvalFunctionIndex(105), }, { /* [613] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(942), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(92), - }, - { - /* [614] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(94), - }, - { - /* [615] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(211), - /* const_eval_fn */ ConstEvalFunctionIndex(94), - }, - { - /* [616] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(94), - }, - { - /* [617] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(94), - }, - { - /* [618] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(95), - }, - { - /* [619] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(211), - /* const_eval_fn */ ConstEvalFunctionIndex(95), - }, - { - /* [620] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(95), - }, - { - /* [621] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(95), - }, - { - /* [622] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(43), - }, - { - /* [623] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(43), - }, - { - /* [624] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(777), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(43), - }, - { - /* [625] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(780), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(63), - }, - { - /* [626] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(772), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(63), - }, - { - /* [627] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(222), - /* parameters */ ParameterIndex(783), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(64), - }, - { - /* [628] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 4, - /* templates */ TemplateIndex(31), - /* parameters */ ParameterIndex(927), - /* return_matcher_indices */ MatcherIndicesIndex(91), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [629] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(39), - /* parameters */ ParameterIndex(929), - /* return_matcher_indices */ MatcherIndicesIndex(136), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [630] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(39), - /* parameters */ ParameterIndex(931), - /* return_matcher_indices */ MatcherIndicesIndex(141), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [631] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [632] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(991), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [633] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(269), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(17), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [634] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [635] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [636] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(270), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [637] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [638] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(970), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [639] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(271), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [640] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(27), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [641] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(961), - /* return_matcher_indices */ MatcherIndicesIndex(27), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [642] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(272), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(27), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [643] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 0, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(106), - }, - { - /* [644] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConstructor, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(107), - }, - { - /* [645] */ - /* flags */ OverloadFlags(OverloadFlag::kIsConverter, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(273), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(108), - }, - { - /* [646] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(0), - }, - { - /* [647] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(133), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(0), - }, - { - /* [648] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(1), - }, - { - /* [649] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(1), - }, - { - /* [650] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(2), - }, - { - /* [651] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(2), - }, - { - /* [652] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(3), - }, - { - /* [653] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(3), - }, - { - /* [654] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(4), - }, - { - /* [655] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(4), - }, - { - /* [656] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(124), - /* parameters */ ParameterIndex(960), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [657] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(217), - /* parameters */ ParameterIndex(960), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [658] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(5), - }, - { - /* [659] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(5), - }, - { - /* [660] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(6), - }, - { - /* [661] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(6), - }, - { - /* [662] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(7), - }, - { - /* [663] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(7), - }, - { - /* [664] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(8), - }, - { - /* [665] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(147), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(8), - }, - { - /* [666] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(9), - }, - { - /* [667] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(9), - }, - { - /* [668] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(11), - }, - { - /* [669] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(11), - }, - { - /* [670] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(12), - }, - { - /* [671] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(12), - }, - { - /* [672] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(13), - }, - { - /* [673] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(13), - }, - { - /* [674] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(14), - }, - { - /* [675] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(14), - }, - { - /* [676] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(15), - }, - { - /* [677] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(15), - }, - { - /* [678] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(16), - }, - { - /* [679] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(16), - }, - { - /* [680] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(17), - }, - { - /* [681] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(17), - }, - { - /* [682] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(19), - }, - { - /* [683] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(19), - }, - { - /* [684] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(21), - }, - { - /* [685] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(31), - /* const_eval_fn */ ConstEvalFunctionIndex(21), - }, - { - /* [686] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(970), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [687] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(971), - /* return_matcher_indices */ MatcherIndicesIndex(232), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [688] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(25), - }, - { - /* [689] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(25), - }, - { - /* [690] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(26), - }, - { - /* [691] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(26), - }, - { - /* [692] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(16), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(27), - }, - { - /* [693] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(552), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(27), - }, - { - /* [694] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(29), - }, - { - /* [695] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(29), - }, - { - /* [696] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(30), - }, - { - /* [697] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(30), - }, - { - /* [698] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(31), - }, - { - /* [699] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(31), - }, - { - /* [700] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(32), - }, - { - /* [701] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(32), - }, - { - /* [702] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(33), - }, - { - /* [703] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(33), - }, - { - /* [704] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(413), - /* const_eval_fn */ ConstEvalFunctionIndex(34), - }, - { - /* [705] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(235), - /* const_eval_fn */ ConstEvalFunctionIndex(34), - }, - { - /* [706] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(15), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(35), - }, - { - /* [707] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 4, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(35), - }, - { - /* [708] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(36), - }, - { - /* [709] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(36), - }, - { - /* [710] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(865), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(37), - }, - { - /* [711] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 3, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(867), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(37), - }, - { - /* [712] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(38), - }, - { - /* [713] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(31), - /* const_eval_fn */ ConstEvalFunctionIndex(38), - }, - { - /* [714] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(39), - }, - { - /* [715] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(39), - }, - { - /* [716] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(40), - }, - { - /* [717] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(40), - }, - { - /* [718] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(41), - }, - { - /* [719] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(133), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(41), - }, - { - /* [720] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(42), - }, - { - /* [721] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(133), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(42), - }, - { - /* [722] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(415), - /* const_eval_fn */ ConstEvalFunctionIndex(44), - }, - { - /* [723] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(241), - /* const_eval_fn */ ConstEvalFunctionIndex(44), - }, - { - /* [724] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(55), - }, - { - /* [725] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(55), - }, - { - /* [726] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(970), - /* return_matcher_indices */ MatcherIndicesIndex(20), - /* const_eval_fn */ ConstEvalFunctionIndex(56), - }, - { - /* [727] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(971), - /* return_matcher_indices */ MatcherIndicesIndex(232), - /* const_eval_fn */ ConstEvalFunctionIndex(56), - }, - { - /* [728] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(57), - }, - { - /* [729] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(57), - }, - { - /* [730] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(60), - }, - { - /* [731] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(60), - }, - { - /* [732] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(61), - }, - { - /* [733] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(61), - }, - { - /* [734] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(62), - }, - { - /* [735] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(147), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(62), - }, - { - /* [736] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(225), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(65), - }, - { - /* [737] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(224), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(65), - }, - { - /* [738] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(66), - }, - { - /* [739] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(66), - }, - { - /* [740] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(67), - }, - { - /* [741] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(67), - }, - { - /* [742] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(68), - }, - { - /* [743] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 3, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(68), - }, - { - /* [744] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(69), - }, - { - /* [745] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(69), - }, - { - /* [746] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(70), - }, - { - /* [747] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(70), - }, - { - /* [748] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(71), - }, - { - /* [749] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(71), - }, - { - /* [750] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(72), - }, - { - /* [751] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(72), - }, - { - /* [752] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(74), - }, - { - /* [753] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(74), - }, - { - /* [754] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(268), - /* parameters */ ParameterIndex(977), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [755] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(978), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [756] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(844), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [757] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(850), - /* return_matcher_indices */ MatcherIndicesIndex(4), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [758] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(905), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [759] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(907), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [760] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(905), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [761] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(907), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [762] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(909), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [763] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(911), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [764] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(913), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [765] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(915), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [766] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(917), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [767] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(919), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [768] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(48), - /* parameters */ ParameterIndex(905), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [769] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(135), - /* parameters */ ParameterIndex(907), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [770] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(921), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [771] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(923), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [772] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(32), - /* parameters */ ParameterIndex(921), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [773] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(226), - /* parameters */ ParameterIndex(923), - /* return_matcher_indices */ MatcherIndicesIndex(208), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [774] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(230), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [775] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(229), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), - /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), - }, - { - /* [776] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 0, - /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(82), - }, - { - /* [777] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(785), - /* return_matcher_indices */ MatcherIndicesIndex(211), - /* const_eval_fn */ ConstEvalFunctionIndex(82), - }, - { - /* [778] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(83), - }, - { - /* [779] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(83), - }, - { - /* [780] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(225), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(84), - }, - { - /* [781] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 1, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(225), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(84), - }, - { - /* [782] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(93), - }, - { - /* [783] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(93), - }, - { - /* [784] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(98), - }, - { - /* [785] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(400), - /* const_eval_fn */ ConstEvalFunctionIndex(98), - }, - { - /* [786] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(99), - }, - { - /* [787] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(223), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(400), - /* const_eval_fn */ ConstEvalFunctionIndex(99), - }, - { - /* [788] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(100), - }, - { - /* [789] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(400), - /* const_eval_fn */ ConstEvalFunctionIndex(100), - }, - { - /* [790] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(101), - }, - { - /* [791] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(400), - /* const_eval_fn */ ConstEvalFunctionIndex(101), - }, - { - /* [792] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(102), - }, - { - /* [793] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(400), - /* const_eval_fn */ ConstEvalFunctionIndex(102), - }, - { - /* [794] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(1), - /* return_matcher_indices */ MatcherIndicesIndex(213), - /* const_eval_fn */ ConstEvalFunctionIndex(103), - }, - { - /* [795] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(134), - /* parameters */ ParameterIndex(771), - /* return_matcher_indices */ MatcherIndicesIndex(400), - /* const_eval_fn */ ConstEvalFunctionIndex(103), - }, - { - /* [796] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(16), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(104), - }, - { - /* [797] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(943), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(104), - }, - { - /* [798] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(16), - /* return_matcher_indices */ MatcherIndicesIndex(6), - /* const_eval_fn */ ConstEvalFunctionIndex(105), - }, - { - /* [799] */ - /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 2, - /* templates */ TemplateIndex(255), - /* parameters */ ParameterIndex(943), - /* return_matcher_indices */ MatcherIndicesIndex(214), - /* const_eval_fn */ ConstEvalFunctionIndex(105), - }, - { - /* [800] */ - /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), - /* num_parameters */ 2, - /* num_explicit_templates */ 0, - /* num_templates */ 1, - /* templates */ TemplateIndex(128), - /* parameters */ ParameterIndex(763), - /* return_matcher_indices */ MatcherIndicesIndex(411), + /* templates */ TemplateIndex(257), + /* parameters */ ParameterIndex(295), + /* return_matcher_indices */ MatcherIndicesIndex(327), /* const_eval_fn */ ConstEvalFunctionIndex(18), }, { - /* [801] */ + /* [614] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(969), - /* return_matcher_indices */ MatcherIndicesIndex(31), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(498), + /* return_matcher_indices */ MatcherIndicesIndex(45), /* const_eval_fn */ ConstEvalFunctionIndex(20), }, { - /* [802] */ + /* [615] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(133), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(31), + /* templates */ TemplateIndex(314), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(45), /* const_eval_fn */ ConstEvalFunctionIndex(22), }, { - /* [803] */ + /* [616] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(17), + /* return_matcher_indices */ MatcherIndicesIndex(15), /* const_eval_fn */ ConstEvalFunctionIndex(23), }, { - /* [804] */ + /* [617] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, @@ -19810,238 +15190,238 @@ constexpr OverloadInfo kOverloads[] = { /* const_eval_fn */ ConstEvalFunctionIndex(24), }, { - /* [805] */ + /* [618] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(776), - /* return_matcher_indices */ MatcherIndicesIndex(208), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(308), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(28), }, { - /* [806] */ + /* [619] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(45), }, { - /* [807] */ + /* [620] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(972), + /* parameters */ ParameterIndex(501), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(46), }, { - /* [808] */ + /* [621] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(972), + /* parameters */ ParameterIndex(501), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(47), }, { - /* [809] */ + /* [622] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(972), + /* parameters */ ParameterIndex(501), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(48), }, { - /* [810] */ + /* [623] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(973), + /* parameters */ ParameterIndex(502), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(49), }, { - /* [811] */ + /* [624] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(973), + /* parameters */ ParameterIndex(502), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(50), }, { - /* [812] */ + /* [625] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(974), + /* parameters */ ParameterIndex(503), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(51), }, { - /* [813] */ + /* [626] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(975), + /* parameters */ ParameterIndex(504), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(52), }, { - /* [814] */ + /* [627] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(974), + /* parameters */ ParameterIndex(503), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(53), }, { - /* [815] */ + /* [628] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(975), + /* parameters */ ParameterIndex(504), /* return_matcher_indices */ MatcherIndicesIndex(4), /* const_eval_fn */ ConstEvalFunctionIndex(54), }, { - /* [816] */ + /* [629] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(551), - /* return_matcher_indices */ MatcherIndicesIndex(208), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(179), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(58), }, { - /* [817] */ + /* [630] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(127), - /* parameters */ ParameterIndex(777), - /* return_matcher_indices */ MatcherIndicesIndex(208), + /* templates */ TemplateIndex(267), + /* parameters */ ParameterIndex(309), + /* return_matcher_indices */ MatcherIndicesIndex(247), /* const_eval_fn */ ConstEvalFunctionIndex(59), }, { - /* [818] */ + /* [631] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(145), - /* parameters */ ParameterIndex(976), - /* return_matcher_indices */ MatcherIndicesIndex(160), + /* templates */ TemplateIndex(270), + /* parameters */ ParameterIndex(505), + /* return_matcher_indices */ MatcherIndicesIndex(199), /* const_eval_fn */ ConstEvalFunctionIndex(73), }, { - /* [819] */ + /* [632] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(417), + /* return_matcher_indices */ MatcherIndicesIndex(333), /* const_eval_fn */ ConstEvalFunctionIndex(75), }, { - /* [820] */ + /* [633] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(417), + /* return_matcher_indices */ MatcherIndicesIndex(333), /* const_eval_fn */ ConstEvalFunctionIndex(76), }, { - /* [821] */ + /* [634] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(417), + /* return_matcher_indices */ MatcherIndicesIndex(333), /* const_eval_fn */ ConstEvalFunctionIndex(77), }, { - /* [822] */ + /* [635] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(78), }, { - /* [823] */ + /* [636] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(419), + /* return_matcher_indices */ MatcherIndicesIndex(335), /* const_eval_fn */ ConstEvalFunctionIndex(79), }, { - /* [824] */ + /* [637] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(421), + /* return_matcher_indices */ MatcherIndicesIndex(337), /* const_eval_fn */ ConstEvalFunctionIndex(80), }, { - /* [825] */ + /* [638] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(17), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(81), }, { - /* [826] */ + /* [639] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 0, /* num_explicit_templates */ 0, @@ -20052,146 +15432,146 @@ constexpr OverloadInfo kOverloads[] = { /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [827] */ + /* [640] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 1, - /* templates */ TemplateIndex(92), - /* parameters */ ParameterIndex(984), - /* return_matcher_indices */ MatcherIndicesIndex(441), + /* templates */ TemplateIndex(217), + /* parameters */ ParameterIndex(513), + /* return_matcher_indices */ MatcherIndicesIndex(357), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [828] */ + /* [641] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(136), + /* templates */ TemplateIndex(317), /* parameters */ ParameterIndex(0), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [829] */ + /* [642] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(136), + /* templates */ TemplateIndex(317), /* parameters */ ParameterIndex(0), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [830] */ + /* [643] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(136), + /* templates */ TemplateIndex(317), /* parameters */ ParameterIndex(0), - /* return_matcher_indices */ MatcherIndicesIndex(6), + /* return_matcher_indices */ MatcherIndicesIndex(61), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [831] */ + /* [644] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 3, /* num_explicit_templates */ 0, /* num_templates */ 2, - /* templates */ TemplateIndex(136), + /* templates */ TemplateIndex(317), /* parameters */ ParameterIndex(0), - /* return_matcher_indices */ MatcherIndicesIndex(477), + /* return_matcher_indices */ MatcherIndicesIndex(383), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [832] */ + /* [645] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(903), + /* parameters */ ParameterIndex(438), /* return_matcher_indices */ MatcherIndicesIndex(/* invalid */), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [833] */ + /* [646] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(423), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(339), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [834] */ + /* [647] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 0, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), /* parameters */ ParameterIndex(/* invalid */), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [835] */ + /* [648] */ /* flags */ OverloadFlags(OverloadFlag::kIsBuiltin, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [836] */ + /* [649] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(211), - /* parameters */ ParameterIndex(989), - /* return_matcher_indices */ MatcherIndicesIndex(184), + /* templates */ TemplateIndex(308), + /* parameters */ ParameterIndex(518), + /* return_matcher_indices */ MatcherIndicesIndex(223), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [837] */ + /* [650] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 1, /* num_explicit_templates */ 0, /* num_templates */ 3, - /* templates */ TemplateIndex(211), - /* parameters */ ParameterIndex(990), - /* return_matcher_indices */ MatcherIndicesIndex(188), + /* templates */ TemplateIndex(308), + /* parameters */ ParameterIndex(519), + /* return_matcher_indices */ MatcherIndicesIndex(227), /* const_eval_fn */ ConstEvalFunctionIndex(/* invalid */), }, { - /* [838] */ + /* [651] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(96), }, { - /* [839] */ + /* [652] */ /* flags */ OverloadFlags(OverloadFlag::kIsOperator, OverloadFlag::kSupportsVertexPipeline, OverloadFlag::kSupportsFragmentPipeline, OverloadFlag::kSupportsComputePipeline, OverloadFlag::kMustUse), /* num_parameters */ 2, /* num_explicit_templates */ 0, /* num_templates */ 0, /* templates */ TemplateIndex(/* invalid */), - /* parameters */ ParameterIndex(774), - /* return_matcher_indices */ MatcherIndicesIndex(213), + /* parameters */ ParameterIndex(306), + /* return_matcher_indices */ MatcherIndicesIndex(151), /* const_eval_fn */ ConstEvalFunctionIndex(97), }, }; @@ -20205,77 +15585,78 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn abs[T : fia_fiu32_f16](T) -> T */ /* fn abs[N : num, T : fia_fiu32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(646), + /* overloads */ OverloadIndex(459), }, { /* [1] */ /* fn acos[T : fa_f32_f16](@test_value(0.96891242171) T) -> T */ /* fn acos[N : num, T : fa_f32_f16](@test_value(0.96891242171) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(648), + /* overloads */ OverloadIndex(461), }, { /* [2] */ /* fn acosh[T : fa_f32_f16](@test_value(1.5430806348) T) -> T */ /* fn acosh[N : num, T : fa_f32_f16](@test_value(1.5430806348) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(650), + /* overloads */ OverloadIndex(463), }, { /* [3] */ /* fn all(bool) -> bool */ /* fn all[N : num](vec) -> bool */ /* num overloads */ 2, - /* overloads */ OverloadIndex(652), + /* overloads */ OverloadIndex(465), }, { /* [4] */ /* fn any(bool) -> bool */ /* fn any[N : num](vec) -> bool */ /* num overloads */ 2, - /* overloads */ OverloadIndex(654), + /* overloads */ OverloadIndex(467), }, { /* [5] */ - /* fn arrayLength[T, R : read](ptr, R>) -> u32 */ + /* fn arrayLength[AS : uniform_or_storage, T, R : read](ptr, R>) -> u32 */ /* fn arrayLength[T, W : writable](ptr, W>) -> u32 */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(656), + /* fn arrayLength[T, W : writable](ptr, W>) -> u32 */ + /* num overloads */ 3, + /* overloads */ OverloadIndex(432), }, { /* [6] */ /* fn asin[T : fa_f32_f16](@test_value(0.479425538604) T) -> T */ /* fn asin[N : num, T : fa_f32_f16](@test_value(0.479425538604) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(658), + /* overloads */ OverloadIndex(469), }, { /* [7] */ /* fn asinh[T : fa_f32_f16](T) -> T */ /* fn asinh[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(660), + /* overloads */ OverloadIndex(471), }, { /* [8] */ /* fn atan[T : fa_f32_f16](T) -> T */ /* fn atan[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(662), + /* overloads */ OverloadIndex(473), }, { /* [9] */ /* fn atan2[T : fa_f32_f16](T, T) -> T */ /* fn atan2[T : fa_f32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(664), + /* overloads */ OverloadIndex(475), }, { /* [10] */ /* fn atanh[T : fa_f32_f16](@test_value(0.5) T) -> T */ /* fn atanh[N : num, T : fa_f32_f16](@test_value(0.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(666), + /* overloads */ OverloadIndex(477), }, { /* [11] */ @@ -20290,288 +15671,288 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn bitcast>[S : fiu32](S) -> T */ /* fn bitcast>[S : fiu32](vec2) -> T */ /* num overloads */ 10, - /* overloads */ OverloadIndex(432), + /* overloads */ OverloadIndex(236), }, { /* [12] */ /* fn ceil[T : fa_f32_f16](@test_value(1.5) T) -> T */ /* fn ceil[N : num, T : fa_f32_f16](@test_value(1.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(668), + /* overloads */ OverloadIndex(479), }, { /* [13] */ /* fn clamp[T : fia_fiu32_f16](T, T, T) -> T */ /* fn clamp[T : fia_fiu32_f16, N : num](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(670), + /* overloads */ OverloadIndex(481), }, { /* [14] */ /* fn cos[T : fa_f32_f16](@test_value(0) T) -> T */ /* fn cos[N : num, T : fa_f32_f16](@test_value(0) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(672), + /* overloads */ OverloadIndex(483), }, { /* [15] */ /* fn cosh[T : fa_f32_f16](@test_value(0) T) -> T */ /* fn cosh[N : num, T : fa_f32_f16](@test_value(0) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(674), + /* overloads */ OverloadIndex(485), }, { /* [16] */ /* fn countLeadingZeros[T : iu32](T) -> T */ /* fn countLeadingZeros[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(676), + /* overloads */ OverloadIndex(487), }, { /* [17] */ /* fn countOneBits[T : iu32](T) -> T */ /* fn countOneBits[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(678), + /* overloads */ OverloadIndex(489), }, { /* [18] */ /* fn countTrailingZeros[T : iu32](T) -> T */ /* fn countTrailingZeros[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(680), + /* overloads */ OverloadIndex(491), }, { /* [19] */ /* fn cross[T : fa_f32_f16](vec3, vec3) -> vec3 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(800), + /* overloads */ OverloadIndex(613), }, { /* [20] */ /* fn degrees[T : fa_f32_f16](T) -> T */ /* fn degrees[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(682), + /* overloads */ OverloadIndex(493), }, { /* [21] */ /* fn determinant[N : num, T : fa_f32_f16](mat) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(801), + /* overloads */ OverloadIndex(614), }, { /* [22] */ /* fn distance[T : fa_f32_f16](T, T) -> T */ /* fn distance[N : num, T : fa_f32_f16](vec, vec) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(684), + /* overloads */ OverloadIndex(495), }, { /* [23] */ /* fn dot[N : num, T : fia_fiu32_f16](vec, vec) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(802), + /* overloads */ OverloadIndex(615), }, { /* [24] */ /* fn dot4I8Packed(u32, u32) -> i32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(803), + /* overloads */ OverloadIndex(616), }, { /* [25] */ /* fn dot4U8Packed(u32, u32) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(804), + /* overloads */ OverloadIndex(617), }, { /* [26] */ /* fn dpdx(f32) -> f32 */ /* fn dpdx[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [27] */ /* fn dpdxCoarse(f32) -> f32 */ /* fn dpdxCoarse[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [28] */ /* fn dpdxFine(f32) -> f32 */ /* fn dpdxFine[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [29] */ /* fn dpdy(f32) -> f32 */ /* fn dpdy[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [30] */ /* fn dpdyCoarse(f32) -> f32 */ /* fn dpdyCoarse[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [31] */ /* fn dpdyFine(f32) -> f32 */ /* fn dpdyFine[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [32] */ /* fn exp[T : fa_f32_f16](T) -> T */ /* fn exp[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(688), + /* overloads */ OverloadIndex(499), }, { /* [33] */ /* fn exp2[T : fa_f32_f16](T) -> T */ /* fn exp2[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(690), + /* overloads */ OverloadIndex(501), }, { /* [34] */ /* fn extractBits[T : iu32](T, u32, u32) -> T */ /* fn extractBits[N : num, T : iu32](vec, u32, u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(692), + /* overloads */ OverloadIndex(503), }, { /* [35] */ /* fn faceForward[N : num, T : fa_f32_f16](vec, vec, vec) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(805), + /* overloads */ OverloadIndex(618), }, { /* [36] */ /* fn firstLeadingBit[T : iu32](T) -> T */ /* fn firstLeadingBit[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(694), + /* overloads */ OverloadIndex(505), }, { /* [37] */ /* fn firstTrailingBit[T : iu32](T) -> T */ /* fn firstTrailingBit[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(696), + /* overloads */ OverloadIndex(507), }, { /* [38] */ /* fn floor[T : fa_f32_f16](@test_value(1.5) T) -> T */ /* fn floor[N : num, T : fa_f32_f16](@test_value(1.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(698), + /* overloads */ OverloadIndex(509), }, { /* [39] */ /* fn fma[T : fa_f32_f16](T, T, T) -> T */ /* fn fma[N : num, T : fa_f32_f16](vec, vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(700), + /* overloads */ OverloadIndex(511), }, { /* [40] */ /* fn fract[T : fa_f32_f16](@test_value(1.25) T) -> T */ /* fn fract[N : num, T : fa_f32_f16](@test_value(1.25) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(702), + /* overloads */ OverloadIndex(513), }, { /* [41] */ /* fn frexp[T : fa_f32_f16](T) -> __frexp_result */ /* fn frexp[N : num, T : fa_f32_f16](vec) -> __frexp_result_vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(704), + /* overloads */ OverloadIndex(515), }, { /* [42] */ /* fn fwidth(f32) -> f32 */ /* fn fwidth[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [43] */ /* fn fwidthCoarse(f32) -> f32 */ /* fn fwidthCoarse[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [44] */ /* fn fwidthFine(f32) -> f32 */ /* fn fwidthFine[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(686), + /* overloads */ OverloadIndex(497), }, { /* [45] */ /* fn insertBits[T : iu32](T, T, u32, u32) -> T */ /* fn insertBits[N : num, T : iu32](vec, vec, u32, u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(706), + /* overloads */ OverloadIndex(517), }, { /* [46] */ /* fn inverseSqrt[T : fa_f32_f16](T) -> T */ /* fn inverseSqrt[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(708), + /* overloads */ OverloadIndex(519), }, { /* [47] */ /* fn ldexp[T : fa_f32_f16, U : ia_i32](T, U) -> T */ /* fn ldexp[N : num, T : fa_f32_f16, U : ia_i32](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(710), + /* overloads */ OverloadIndex(521), }, { /* [48] */ /* fn length[T : fa_f32_f16](@test_value(0) T) -> T */ /* fn length[N : num, T : fa_f32_f16](@test_value(0) vec) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(712), + /* overloads */ OverloadIndex(523), }, { /* [49] */ /* fn log[T : fa_f32_f16](T) -> T */ /* fn log[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(714), + /* overloads */ OverloadIndex(525), }, { /* [50] */ /* fn log2[T : fa_f32_f16](T) -> T */ /* fn log2[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(716), + /* overloads */ OverloadIndex(527), }, { /* [51] */ /* fn max[T : fia_fiu32_f16](T, T) -> T */ /* fn max[N : num, T : fia_fiu32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(718), + /* overloads */ OverloadIndex(529), }, { /* [52] */ /* fn min[T : fia_fiu32_f16](T, T) -> T */ /* fn min[N : num, T : fia_fiu32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(720), + /* overloads */ OverloadIndex(531), }, { /* [53] */ @@ -20579,128 +15960,128 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn mix[N : num, T : fa_f32_f16](vec, vec, vec) -> vec */ /* fn mix[N : num, T : fa_f32_f16](vec, vec, T) -> vec */ /* num overloads */ 3, - /* overloads */ OverloadIndex(622), + /* overloads */ OverloadIndex(435), }, { /* [54] */ /* fn modf[T : fa_f32_f16](@test_value(-1.5) T) -> __modf_result */ /* fn modf[N : num, T : fa_f32_f16](@test_value(-1.5) vec) -> __modf_result_vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(722), + /* overloads */ OverloadIndex(533), }, { /* [55] */ /* fn normalize[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(806), + /* overloads */ OverloadIndex(619), }, { /* [56] */ /* fn pack2x16float(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(807), + /* overloads */ OverloadIndex(620), }, { /* [57] */ /* fn pack2x16snorm(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(808), + /* overloads */ OverloadIndex(621), }, { /* [58] */ /* fn pack2x16unorm(vec2) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(809), + /* overloads */ OverloadIndex(622), }, { /* [59] */ /* fn pack4x8snorm(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(810), + /* overloads */ OverloadIndex(623), }, { /* [60] */ /* fn pack4x8unorm(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(811), + /* overloads */ OverloadIndex(624), }, { /* [61] */ /* fn pack4xI8(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(812), + /* overloads */ OverloadIndex(625), }, { /* [62] */ /* fn pack4xU8(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(813), + /* overloads */ OverloadIndex(626), }, { /* [63] */ /* fn pack4xI8Clamp(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(814), + /* overloads */ OverloadIndex(627), }, { /* [64] */ /* fn pack4xU8Clamp(vec4) -> u32 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(815), + /* overloads */ OverloadIndex(628), }, { /* [65] */ /* fn pow[T : fa_f32_f16](T, T) -> T */ /* fn pow[N : num, T : fa_f32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(724), + /* overloads */ OverloadIndex(535), }, { /* [66] */ /* fn quantizeToF16(f32) -> f32 */ /* fn quantizeToF16[N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(726), + /* overloads */ OverloadIndex(537), }, { /* [67] */ /* fn radians[T : fa_f32_f16](T) -> T */ /* fn radians[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(728), + /* overloads */ OverloadIndex(539), }, { /* [68] */ /* fn reflect[N : num, T : fa_f32_f16](vec, vec) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(816), + /* overloads */ OverloadIndex(629), }, { /* [69] */ /* fn refract[N : num, T : fa_f32_f16](vec, vec, T) -> vec */ /* num overloads */ 1, - /* overloads */ OverloadIndex(817), + /* overloads */ OverloadIndex(630), }, { /* [70] */ /* fn reverseBits[T : iu32](T) -> T */ /* fn reverseBits[N : num, T : iu32](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(730), + /* overloads */ OverloadIndex(541), }, { /* [71] */ /* fn round[T : fa_f32_f16](@test_value(3.5) T) -> T */ /* fn round[N : num, T : fa_f32_f16](@test_value(3.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(732), + /* overloads */ OverloadIndex(543), }, { /* [72] */ /* fn saturate[T : fa_f32_f16](@test_value(2) T) -> T */ /* fn saturate[T : fa_f32_f16, N : num](@test_value(2) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(734), + /* overloads */ OverloadIndex(545), }, { /* [73] */ @@ -20708,143 +16089,143 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn select[T : scalar, N : num](vec, vec, bool) -> vec */ /* fn select[N : num, T : scalar](vec, vec, vec) -> vec */ /* num overloads */ 3, - /* overloads */ OverloadIndex(625), + /* overloads */ OverloadIndex(438), }, { /* [74] */ /* fn sign[T : fia_fi32_f16](T) -> T */ /* fn sign[N : num, T : fia_fi32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(736), + /* overloads */ OverloadIndex(547), }, { /* [75] */ /* fn sin[T : fa_f32_f16](@test_value(1.57079632679) T) -> T */ /* fn sin[N : num, T : fa_f32_f16](@test_value(1.57079632679) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(738), + /* overloads */ OverloadIndex(549), }, { /* [76] */ /* fn sinh[T : fa_f32_f16](T) -> T */ /* fn sinh[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(740), + /* overloads */ OverloadIndex(551), }, { /* [77] */ /* fn smoothstep[T : fa_f32_f16](@test_value(2) T, @test_value(4) T, @test_value(3) T) -> T */ /* fn smoothstep[N : num, T : fa_f32_f16](@test_value(2) vec, @test_value(4) vec, @test_value(3) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(742), + /* overloads */ OverloadIndex(553), }, { /* [78] */ /* fn sqrt[T : fa_f32_f16](T) -> T */ /* fn sqrt[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(744), + /* overloads */ OverloadIndex(555), }, { /* [79] */ /* fn step[T : fa_f32_f16](T, T) -> T */ /* fn step[N : num, T : fa_f32_f16](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(746), + /* overloads */ OverloadIndex(557), }, { /* [80] */ /* fn tan[T : fa_f32_f16](T) -> T */ /* fn tan[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(748), + /* overloads */ OverloadIndex(559), }, { /* [81] */ /* fn tanh[T : fa_f32_f16](T) -> T */ /* fn tanh[N : num, T : fa_f32_f16](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(750), + /* overloads */ OverloadIndex(561), }, { /* [82] */ /* fn transpose[M : num, N : num, T : fa_f32_f16](mat) -> mat */ /* num overloads */ 1, - /* overloads */ OverloadIndex(818), + /* overloads */ OverloadIndex(631), }, { /* [83] */ /* fn trunc[T : fa_f32_f16](@test_value(1.5) T) -> T */ /* fn trunc[N : num, T : fa_f32_f16](@test_value(1.5) vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(752), + /* overloads */ OverloadIndex(563), }, { /* [84] */ /* fn unpack2x16float(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(819), + /* overloads */ OverloadIndex(632), }, { /* [85] */ /* fn unpack2x16snorm(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(820), + /* overloads */ OverloadIndex(633), }, { /* [86] */ /* fn unpack2x16unorm(u32) -> vec2 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(821), + /* overloads */ OverloadIndex(634), }, { /* [87] */ /* fn unpack4x8snorm(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(822), + /* overloads */ OverloadIndex(635), }, { /* [88] */ /* fn unpack4x8unorm(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(823), + /* overloads */ OverloadIndex(636), }, { /* [89] */ /* fn unpack4xI8(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(824), + /* overloads */ OverloadIndex(637), }, { /* [90] */ /* fn unpack4xU8(u32) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(825), + /* overloads */ OverloadIndex(638), }, { /* [91] */ /* fn workgroupUniformLoad[T : __constructible](ptr) -> T */ /* fn workgroupUniformLoad[T : iu32](ptr, read_write>) -> T */ /* num overloads */ 2, - /* overloads */ OverloadIndex(754), + /* overloads */ OverloadIndex(565), }, { /* [92] */ /* fn storageBarrier() */ /* num overloads */ 1, - /* overloads */ OverloadIndex(826), + /* overloads */ OverloadIndex(639), }, { /* [93] */ /* fn workgroupBarrier() */ /* num overloads */ 1, - /* overloads */ OverloadIndex(826), + /* overloads */ OverloadIndex(639), }, { /* [94] */ /* fn textureBarrier() */ /* num overloads */ 1, - /* overloads */ OverloadIndex(826), + /* overloads */ OverloadIndex(639), }, { /* [95] */ @@ -20860,18 +16241,6 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureDimensions[T : fiu32, L : iu32](texture: texture_cube, level: L) -> vec2 */ /* fn textureDimensions[T : fiu32](texture: texture_cube_array) -> vec2 */ /* fn textureDimensions[T : fiu32, L : iu32](texture: texture_cube_array, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_1d_filtered) -> u32 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_1d_filtered, level: L) -> u32 */ - /* fn textureDimensions[K : texture_filter](texture: texture_2d_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_2d_filtered, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_2d_array_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_2d_array_filtered, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_3d_filtered) -> vec3 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_3d_filtered, level: L) -> vec3 */ - /* fn textureDimensions[K : texture_filter](texture: texture_cube_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_cube_filtered, level: L) -> vec2 */ - /* fn textureDimensions[K : texture_filter](texture: texture_cube_array_filtered) -> vec2 */ - /* fn textureDimensions[K : texture_filter, L : iu32](texture: texture_cube_array_filtered, level: L) -> vec2 */ /* fn textureDimensions[T : fiu32](texture: texture_multisampled_2d) -> vec2 */ /* fn textureDimensions(texture: texture_depth_2d) -> vec2 */ /* fn textureDimensions[L : iu32](texture: texture_depth_2d, level: L) -> vec2 */ @@ -20893,49 +16262,25 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureDimensions[F : texel_format, R : read](texture: texel_buffer) -> u32 */ /* fn textureDimensions[F : texel_format, W : writable](texture: texel_buffer) -> u32 */ /* fn textureDimensions(texture: texture_external) -> vec2 */ - /* num overloads */ 45, - /* overloads */ OverloadIndex(102), + /* num overloads */ 33, + /* overloads */ OverloadIndex(39), }, { /* [96] */ /* fn textureGather[T : fiu32, C : iu32](@const component: C, texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, K : sampler_filter](@const component: C, texture: texture_2d, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, F : texture_filter, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, K : sampler_filter, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32](@const component: C, texture: texture_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, K : sampler_filter](@const component: C, texture: texture_2d, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, F : texture_filter](@const component: C, texture: texture_2d_filtered, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, K : sampler_filter](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32](@const component: C, texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, F : texture_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, F : texture_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32](@const component: C, texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32](@const component: C, texture: texture_cube, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, K : sampler_filter](@const component: C, texture: texture_cube, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, F : texture_filter, C : iu32](@const component: C, texture: texture_cube_filtered, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, K : sampler_filter, C : iu32](@const component: C, texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureGather[T : f32, C : iu32](@const component: C, texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ /* fn textureGather[T : fiu32, C : iu32, A : iu32](@const component: C, texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, F : texture_filter](@const component: C, texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32, K : sampler_filter](@const component: C, texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureGather[T : f32, C : iu32, A : iu32](@const component: C, texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ /* fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2) -> vec4 */ /* fn textureGather(texture: texture_depth_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ /* fn textureGather[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ /* fn textureGather[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ /* fn textureGather(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> vec4 */ /* fn textureGather[A : iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* num overloads */ 36, - /* overloads */ OverloadIndex(270), + /* num overloads */ 12, + /* overloads */ OverloadIndex(200), }, { /* [97] */ @@ -20946,20 +16291,18 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureGatherCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> vec4 */ /* fn textureGatherCompare[A : iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: A, depth_ref: f32) -> vec4 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(548), + /* overloads */ OverloadIndex(362), }, { /* [98] */ /* fn textureNumLayers[T : fiu32](texture: texture_2d_array) -> u32 */ /* fn textureNumLayers[T : fiu32](texture: texture_cube_array) -> u32 */ - /* fn textureNumLayers[F : texture_filter](texture: texture_2d_array_filtered) -> u32 */ - /* fn textureNumLayers[F : texture_filter](texture: texture_cube_array_filtered) -> u32 */ /* fn textureNumLayers(texture: texture_depth_2d_array) -> u32 */ /* fn textureNumLayers(texture: texture_depth_cube_array) -> u32 */ /* fn textureNumLayers[F : texel_format, R : read](texture: texture_storage_2d_array) -> u32 */ /* fn textureNumLayers[F : texel_format, W : writable](texture: texture_storage_2d_array) -> u32 */ - /* num overloads */ 8, - /* overloads */ OverloadIndex(532), + /* num overloads */ 6, + /* overloads */ OverloadIndex(368), }, { /* [99] */ @@ -20969,126 +16312,52 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureNumLevels[T : fiu32](texture: texture_3d) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_cube) -> u32 */ /* fn textureNumLevels[T : fiu32](texture: texture_cube_array) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_1d_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_2d_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_2d_array_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_3d_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_cube_filtered) -> u32 */ - /* fn textureNumLevels[K : texture_filter](texture: texture_cube_array_filtered) -> u32 */ /* fn textureNumLevels(texture: texture_depth_2d) -> u32 */ /* fn textureNumLevels(texture: texture_depth_2d_array) -> u32 */ /* fn textureNumLevels(texture: texture_depth_cube) -> u32 */ /* fn textureNumLevels(texture: texture_depth_cube_array) -> u32 */ - /* num overloads */ 16, - /* overloads */ OverloadIndex(388), + /* num overloads */ 10, + /* overloads */ OverloadIndex(246), }, { /* [100] */ /* fn textureNumSamples[T : fiu32](texture: texture_multisampled_2d) -> u32 */ /* fn textureNumSamples(texture: texture_depth_multisampled_2d) -> u32 */ /* num overloads */ 2, - /* overloads */ OverloadIndex(756), + /* overloads */ OverloadIndex(567), }, { /* [101] */ /* fn textureSample(texture: texture_1d, sampler: sampler, coords: f32) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_1d, sampler: sampler_filtered, coords: f32) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_1d_filtered, sampler: sampler, coords: f32) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32) -> vec4 */ - /* fn textureSample(texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32) -> vec4 */ /* fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSample(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ /* fn textureSample(texture: texture_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSample(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, @const offset: vec2) -> vec4 */ /* fn textureSample[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[F : texture_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ - /* fn textureSample[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A) -> vec4 */ /* fn textureSample[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[F : texture_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ - /* fn textureSample[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, @const offset: vec2) -> vec4 */ /* fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ /* fn textureSample(texture: texture_3d, sampler: sampler, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSample(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, @const offset: vec3) -> vec4 */ /* fn textureSample(texture: texture_cube, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3) -> vec4 */ - /* fn textureSample[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ - /* fn textureSample(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3) -> vec4 */ /* fn textureSample[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[F : texture_filter, A : iu32](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[K : sampler_filter, A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ - /* fn textureSample[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A) -> vec4 */ /* fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2) -> f32 */ /* fn textureSample(texture: texture_depth_2d, sampler: sampler, coords: vec2, @const offset: vec2) -> f32 */ /* fn textureSample[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A) -> f32 */ /* fn textureSample[A : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, @const offset: vec2) -> f32 */ /* fn textureSample(texture: texture_depth_cube, sampler: sampler, coords: vec3) -> f32 */ /* fn textureSample[A : iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: A) -> f32 */ - /* num overloads */ 51, - /* overloads */ OverloadIndex(0), + /* num overloads */ 15, + /* overloads */ OverloadIndex(114), }, { /* [102] */ /* fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32) -> vec4 */ - /* fn textureSampleBias(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32) -> vec4 */ /* fn textureSampleBias(texture: texture_2d, sampler: sampler, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, bias: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleBias[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32) -> vec4 */ /* fn textureSampleBias[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleBias[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, bias: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ /* fn textureSampleBias(texture: texture_3d, sampler: sampler, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleBias(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, bias: f32, @const offset: vec3) -> vec4 */ /* fn textureSampleBias(texture: texture_cube, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ - /* fn textureSampleBias(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, bias: f32) -> vec4 */ /* fn textureSampleBias[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, F : texture_filter](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32, K : sampler_filter](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* fn textureSampleBias[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, bias: f32) -> vec4 */ - /* num overloads */ 40, - /* overloads */ OverloadIndex(190), + /* num overloads */ 8, + /* overloads */ OverloadIndex(346), }, { /* [103] */ @@ -21099,7 +16368,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleCompare(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 */ /* fn textureSampleCompare[A : iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: A, depth_ref: f32) -> f32 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(554), + /* overloads */ OverloadIndex(374), }, { /* [104] */ @@ -21110,119 +16379,47 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureSampleCompareLevel(texture: texture_depth_cube, sampler: sampler_comparison, coords: vec3, depth_ref: f32) -> f32 */ /* fn textureSampleCompareLevel[A : iu32](texture: texture_depth_cube_array, sampler: sampler_comparison, coords: vec3, array_index: A, depth_ref: f32) -> f32 */ /* num overloads */ 6, - /* overloads */ OverloadIndex(560), + /* overloads */ OverloadIndex(380), }, { /* [105] */ /* fn textureSampleGrad(texture: texture_2d, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2) -> vec4 */ /* fn textureSampleGrad(texture: texture_2d, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ /* fn textureSampleGrad[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2) -> vec4 */ /* fn textureSampleGrad[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ - /* fn textureSampleGrad[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, ddx: vec2, ddy: vec2, @const offset: vec2) -> vec4 */ /* fn textureSampleGrad(texture: texture_3d, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ /* fn textureSampleGrad(texture: texture_3d, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ - /* fn textureSampleGrad(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3, @const offset: vec3) -> vec4 */ /* fn textureSampleGrad(texture: texture_cube, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, ddx: vec3, ddy: vec3) -> vec4 */ /* fn textureSampleGrad[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32, F : texture_filter](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32, K : sampler_filter](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* fn textureSampleGrad[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, ddx: vec3, ddy: vec3) -> vec4 */ - /* num overloads */ 40, - /* overloads */ OverloadIndex(230), + /* num overloads */ 8, + /* overloads */ OverloadIndex(354), }, { /* [106] */ /* fn textureSampleLevel(texture: texture_1d, sampler: sampler, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_1d, sampler: sampler_filtered, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_1d_filtered, sampler: sampler, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_1d_filtered, sampler: sampler_filtered, coords: f32, level: f32) -> vec4 */ /* fn textureSampleLevel(texture: texture_2d, sampler: sampler, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32) -> vec4 */ /* fn textureSampleLevel(texture: texture_2d, sampler: sampler, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2, level: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleLevel[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32) -> vec4 */ /* fn textureSampleLevel[A : iu32](texture: texture_2d_array, sampler: sampler, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32, F : texture_filter](texture: texture_2d_array_filtered, sampler: sampler, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ - /* fn textureSampleLevel[A : iu32](texture: texture_2d_array_filtered, sampler: sampler_filtered, coords: vec2, array_index: A, level: f32, @const offset: vec2) -> vec4 */ /* fn textureSampleLevel(texture: texture_3d, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ /* fn textureSampleLevel(texture: texture_3d, sampler: sampler, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d, sampler: sampler_filtered, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_3d_filtered, sampler: sampler, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ - /* fn textureSampleLevel(texture: texture_3d_filtered, sampler: sampler_filtered, coords: vec3, level: f32, @const offset: vec3) -> vec4 */ /* fn textureSampleLevel(texture: texture_cube, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_cube, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[F : texture_filter](texture: texture_cube_filtered, sampler: sampler, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel[K : sampler_filter](texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ - /* fn textureSampleLevel(texture: texture_cube_filtered, sampler: sampler_filtered, coords: vec3, level: f32) -> vec4 */ /* fn textureSampleLevel[A : iu32](texture: texture_cube_array, sampler: sampler, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_cube_array, sampler: sampler_filtered, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, F : texture_filter](texture: texture_cube_array_filtered, sampler: sampler, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32, K : sampler_filter](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, level: f32) -> vec4 */ - /* fn textureSampleLevel[A : iu32](texture: texture_cube_array_filtered, sampler: sampler_filtered, coords: vec3, array_index: A, level: f32) -> vec4 */ /* fn textureSampleLevel[L : iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2, level: L) -> f32 */ /* fn textureSampleLevel[L : iu32](texture: texture_depth_2d, sampler: sampler, coords: vec2, level: L, @const offset: vec2) -> f32 */ /* fn textureSampleLevel[A : iu32, L : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, level: L) -> f32 */ /* fn textureSampleLevel[A : iu32, L : iu32](texture: texture_depth_2d_array, sampler: sampler, coords: vec2, array_index: A, level: L, @const offset: vec2) -> f32 */ /* fn textureSampleLevel[L : iu32](texture: texture_depth_cube, sampler: sampler, coords: vec3, level: L) -> f32 */ /* fn textureSampleLevel[A : iu32, L : iu32](texture: texture_depth_cube_array, sampler: sampler, coords: vec3, array_index: A, level: L) -> f32 */ - /* num overloads */ 51, - /* overloads */ OverloadIndex(51), + /* num overloads */ 15, + /* overloads */ OverloadIndex(129), }, { /* [107] */ /* fn textureSampleBaseClampToEdge(texture: texture_2d, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge[K : sampler_filter](texture: texture_2d, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge[F : texture_filter](texture: texture_2d_filtered, sampler: sampler, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge[K : sampler_filter](texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ - /* fn textureSampleBaseClampToEdge(texture: texture_2d_filtered, sampler: sampler_filtered, coords: vec2) -> vec4 */ /* fn textureSampleBaseClampToEdge(texture: texture_external, sampler: sampler, coords: vec2) -> vec4 */ - /* num overloads */ 6, - /* overloads */ OverloadIndex(566), + /* num overloads */ 2, + /* overloads */ OverloadIndex(569), }, { /* [108] */ @@ -21242,7 +16439,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureStore[C : iu32, F : u32_texel_format, W : writable](texture: texture_storage_3d, coords: vec3, value: vec4) */ /* fn textureStore[C : iu32, F : u32_texel_format, RW : read_write](texture: texel_buffer, coords: C, value: vec4) */ /* num overloads */ 15, - /* overloads */ OverloadIndex(404), + /* overloads */ OverloadIndex(144), }, { /* [109] */ @@ -21250,10 +16447,6 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureLoad[T : fiu32, C : iu32, L : iu32](texture: texture_2d, coords: vec2, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, A : iu32, L : iu32](texture: texture_2d_array, coords: vec2, array_index: A, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, L : iu32](texture: texture_3d, coords: vec3, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, L : iu32, F : texture_filter](texture: texture_1d_filtered, coords: C, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, L : iu32, F : texture_filter](texture: texture_2d_filtered, coords: vec2, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, A : iu32, L : iu32, F : texture_filter](texture: texture_2d_array_filtered, coords: vec2, array_index: A, level: L) -> vec4 */ - /* fn textureLoad[T : f32, C : iu32, L : iu32, F : texture_filter](texture: texture_3d_filtered, coords: vec3, level: L) -> vec4 */ /* fn textureLoad[T : fiu32, C : iu32, S : iu32](texture: texture_multisampled_2d, coords: vec2, sample_index: S) -> vec4 */ /* fn textureLoad[C : iu32, L : iu32](texture: texture_depth_2d, coords: vec2, level: L) -> f32 */ /* fn textureLoad[C : iu32, A : iu32, L : iu32](texture: texture_depth_2d_array, coords: vec2, array_index: A, level: L) -> f32 */ @@ -21289,285 +16482,297 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn textureLoad[C : iu32, F : f32_texel_format, RW : read_write](texture: texel_buffer, coords: C) -> vec4 */ /* fn textureLoad[C : iu32, F : i32_texel_format, RW : read_write](texture: texel_buffer, coords: C) -> vec4 */ /* fn textureLoad[C : iu32, F : u32_texel_format, RW : read_write](texture: texel_buffer, coords: C) -> vec4 */ - /* num overloads */ 43, - /* overloads */ OverloadIndex(147), + /* num overloads */ 39, + /* overloads */ OverloadIndex(0), }, { /* [110] */ /* fn inputAttachmentLoad[T : fiu32](input_attachment: input_attachment) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(827), + /* overloads */ OverloadIndex(640), }, { /* [111] */ /* fn atomicLoad[T : iu32, S : workgroup_or_storage](ptr, read_write>) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(828), + /* overloads */ OverloadIndex(641), }, { /* [112] */ /* fn atomicStore[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) */ /* num overloads */ 1, - /* overloads */ OverloadIndex(829), + /* overloads */ OverloadIndex(642), }, { /* [113] */ /* fn atomicAdd[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [114] */ /* fn atomicSub[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [115] */ /* fn atomicMax[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [116] */ /* fn atomicMin[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [117] */ /* fn atomicAnd[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [118] */ /* fn atomicOr[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [119] */ /* fn atomicXor[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [120] */ /* fn atomicExchange[T : iu32, S : workgroup_or_storage](ptr, read_write>, T) -> T */ /* num overloads */ 1, - /* overloads */ OverloadIndex(830), + /* overloads */ OverloadIndex(643), }, { /* [121] */ /* fn atomicCompareExchangeWeak[T : iu32, S : workgroup_or_storage](ptr, read_write>, T, T) -> __atomic_compare_exchange_result */ /* num overloads */ 1, - /* overloads */ OverloadIndex(831), + /* overloads */ OverloadIndex(644), }, { /* [122] */ /* fn atomicStoreMax(ptr>, read_write>, vec2) */ /* num overloads */ 1, - /* overloads */ OverloadIndex(832), + /* overloads */ OverloadIndex(645), }, { /* [123] */ /* fn atomicStoreMin(ptr>, read_write>, vec2) */ /* num overloads */ 1, - /* overloads */ OverloadIndex(832), + /* overloads */ OverloadIndex(645), }, { /* [124] */ /* fn subgroupBallot(bool) -> vec4 */ /* num overloads */ 1, - /* overloads */ OverloadIndex(833), + /* overloads */ OverloadIndex(646), }, { /* [125] */ /* fn subgroupElect() -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(834), + /* overloads */ OverloadIndex(647), }, { /* [126] */ - /* fn subgroupBroadcast[T : fiu32_f16](value: T, @const sourceLaneIndex: iu32) -> T */ - /* fn subgroupBroadcast[N : num, T : fiu32_f16](value: vec, @const sourceLaneIndex: iu32) -> vec */ + /* fn subgroupBroadcast[T : fiu32_f16, I : iu32](value: T, @const sourceLaneIndex: I) -> T */ + /* fn subgroupBroadcast[N : num, T : fiu32_f16, I : iu32](value: vec, @const sourceLaneIndex: I) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(758), + /* overloads */ OverloadIndex(571), }, { /* [127] */ /* fn subgroupBroadcastFirst[T : fiu32_f16](value: T) -> T */ /* fn subgroupBroadcastFirst[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [128] */ - /* fn subgroupShuffle[T : fiu32_f16](value: T, sourceLaneIndex: iu32) -> T */ - /* fn subgroupShuffle[N : num, T : fiu32_f16](value: vec, sourceLaneIndex: iu32) -> vec */ + /* fn subgroupShuffle[T : fiu32_f16, I : iu32](value: T, sourceLaneIndex: I) -> T */ + /* fn subgroupShuffle[N : num, T : fiu32_f16, I : iu32](value: vec, sourceLaneIndex: I) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(762), + /* overloads */ OverloadIndex(575), }, { /* [129] */ /* fn subgroupShuffleXor[T : fiu32_f16](value: T, mask: u32) -> T */ /* fn subgroupShuffleXor[N : num, T : fiu32_f16](value: vec, mask: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(764), + /* overloads */ OverloadIndex(577), }, { /* [130] */ /* fn subgroupShuffleUp[T : fiu32_f16](value: T, delta: u32) -> T */ /* fn subgroupShuffleUp[N : num, T : fiu32_f16](value: vec, delta: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(579), }, { /* [131] */ /* fn subgroupShuffleDown[T : fiu32_f16](value: T, delta: u32) -> T */ /* fn subgroupShuffleDown[N : num, T : fiu32_f16](value: vec, delta: u32) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(766), + /* overloads */ OverloadIndex(579), }, { /* [132] */ /* fn subgroupAdd[T : fiu32_f16](value: T) -> T */ /* fn subgroupAdd[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [133] */ /* fn subgroupInclusiveAdd[T : fiu32_f16](value: T) -> T */ /* fn subgroupInclusiveAdd[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [134] */ /* fn subgroupExclusiveAdd[T : fiu32_f16](value: T) -> T */ /* fn subgroupExclusiveAdd[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [135] */ /* fn subgroupMul[T : fiu32_f16](value: T) -> T */ /* fn subgroupMul[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [136] */ /* fn subgroupInclusiveMul[T : fiu32_f16](value: T) -> T */ /* fn subgroupInclusiveMul[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [137] */ /* fn subgroupExclusiveMul[T : fiu32_f16](value: T) -> T */ /* fn subgroupExclusiveMul[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [138] */ /* fn subgroupAnd[T : iu32](value: T) -> T */ /* fn subgroupAnd[N : num, T : iu32](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(768), + /* overloads */ OverloadIndex(581), }, { /* [139] */ /* fn subgroupOr[T : iu32](value: T) -> T */ /* fn subgroupOr[N : num, T : iu32](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(768), + /* overloads */ OverloadIndex(581), }, { /* [140] */ /* fn subgroupXor[T : iu32](value: T) -> T */ /* fn subgroupXor[N : num, T : iu32](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(768), + /* overloads */ OverloadIndex(581), }, { /* [141] */ /* fn subgroupMin[T : fiu32_f16](value: T) -> T */ /* fn subgroupMin[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [142] */ /* fn subgroupMax[T : fiu32_f16](value: T) -> T */ /* fn subgroupMax[N : num, T : fiu32_f16](value: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(760), + /* overloads */ OverloadIndex(573), }, { /* [143] */ /* fn subgroupAll(bool) -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(835), + /* overloads */ OverloadIndex(648), }, { /* [144] */ /* fn subgroupAny(bool) -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(835), + /* overloads */ OverloadIndex(648), }, { /* [145] */ - /* fn quadBroadcast[T : fiu32_f16](e: T, @const id: iu32) -> T */ - /* fn quadBroadcast[N : num, T : fiu32_f16](e: vec, @const id: iu32) -> vec */ + /* fn quadBroadcast[T : fiu32_f16, I : iu32](e: T, @const id: I) -> T */ + /* fn quadBroadcast[N : num, T : fiu32_f16, I : iu32](e: vec, @const id: I) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(770), + /* overloads */ OverloadIndex(583), }, { /* [146] */ /* fn quadSwapX[T : fiu32_f16](e: T) -> T */ /* fn quadSwapX[N : num, T : fiu32_f16](e: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(772), + /* overloads */ OverloadIndex(585), }, { /* [147] */ /* fn quadSwapY[T : fiu32_f16](e: T) -> T */ /* fn quadSwapY[N : num, T : fiu32_f16](e: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(772), + /* overloads */ OverloadIndex(585), }, { /* [148] */ /* fn quadSwapDiagonal[T : fiu32_f16](e: T) -> T */ /* fn quadSwapDiagonal[N : num, T : fiu32_f16](e: vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(772), + /* overloads */ OverloadIndex(585), }, { /* [149] */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num](ptr, readable>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num](ptr, readable>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num](ptr, readable>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num](ptr, readable>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num](ptr, readable>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ - /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num](ptr, readable>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ - /* num overloads */ 6, - /* overloads */ OverloadIndex(572), + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @const col_major: bool, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* fn subgroupMatrixLoad, Majorness : majorness>[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : readable](ptr, AM>, offset: u32, @test_value(8) stride: u32) -> T */ + /* num overloads */ 12, + /* overloads */ OverloadIndex(212), }, { /* [150] */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ - /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num](ptr, writable>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ - /* num overloads */ 6, - /* overloads */ OverloadIndex(578), + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @const col_major: bool, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : fiu32_f16, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : i8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* fn subgroupMatrixStore[K : subgroup_matrix_kind, S : u8, C : num, R : num, AC : num, AS : workgroup_or_storage, AM : writable](ptr, AM>, offset: u32, subgroup_matrix, @test_value(8) stride: u32) */ + /* num overloads */ 12, + /* overloads */ OverloadIndex(224), }, { /* [151] */ @@ -21576,7 +16781,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn subgroupMatrixMultiply[T : iu8, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiply[T : iu32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 4, - /* overloads */ OverloadIndex(594), + /* overloads */ OverloadIndex(396), }, { /* [152] */ @@ -21585,7 +16790,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn subgroupMatrixMultiplyAccumulate[T : iu8, TR : iu32_iu8, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* fn subgroupMatrixMultiplyAccumulate[T : iu32, TR : iu32, C : num, R : num, K : num](subgroup_matrix, subgroup_matrix, subgroup_matrix) -> subgroup_matrix */ /* num overloads */ 4, - /* overloads */ OverloadIndex(598), + /* overloads */ OverloadIndex(400), }, { /* [153] */ @@ -21593,7 +16798,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn subgroupMatrixScalarAdd[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, @test_value(8) s: i32) -> subgroup_matrix */ /* fn subgroupMatrixScalarAdd[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, @test_value(8) s: u32) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(628), + /* overloads */ OverloadIndex(441), }, { /* [154] */ @@ -21601,7 +16806,7 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn subgroupMatrixScalarSubtract[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, @test_value(8) s: i32) -> subgroup_matrix */ /* fn subgroupMatrixScalarSubtract[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, @test_value(8) s: u32) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(628), + /* overloads */ OverloadIndex(441), }, { /* [155] */ @@ -21609,86 +16814,79 @@ constexpr IntrinsicInfo kBuiltins[] = { /* fn subgroupMatrixScalarMultiply[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, @test_value(8) s: i32) -> subgroup_matrix */ /* fn subgroupMatrixScalarMultiply[K : subgroup_matrix_kind, C : num, R : num](m: subgroup_matrix, @test_value(8) s: u32) -> subgroup_matrix */ /* num overloads */ 3, - /* overloads */ OverloadIndex(628), + /* overloads */ OverloadIndex(441), }, { /* [156] */ - /* fn bufferView[R : read, AS : uniform_or_storage, N : num](ptr, R>, offset: u32) -> ptr */ - /* fn bufferView[R : read, AS : uniform_or_storage, N : num](ptr, R>, offset: i32) -> ptr */ - /* fn bufferView[W : read_write, AS : workgroup_or_storage, N : num](ptr, W>, offset: u32) -> ptr */ - /* fn bufferView[W : read_write, AS : workgroup_or_storage, N : num](ptr, W>, offset: i32) -> ptr */ - /* fn bufferView[R : read, AS : uniform_or_storage](ptr, offset: u32) -> ptr */ - /* fn bufferView[R : read, AS : uniform_or_storage](ptr, offset: i32) -> ptr */ - /* fn bufferView[W : read_write, AS : workgroup_or_storage](ptr, offset: u32) -> ptr */ - /* fn bufferView[W : read_write, AS : workgroup_or_storage](ptr, offset: i32) -> ptr */ - /* num overloads */ 8, - /* overloads */ OverloadIndex(540), + /* fn bufferView[R : read, AS : uniform_or_storage, N : num, I : iu32](ptr, R>, offset: I) -> ptr */ + /* fn bufferView[W : read_write, AS : workgroup_or_storage, N : num, I : iu32](ptr, W>, offset: I) -> ptr */ + /* fn bufferView[R : read, AS : uniform_or_storage, I : iu32](ptr, offset: I) -> ptr */ + /* fn bufferView[W : read_write, AS : workgroup_or_storage, I : iu32](ptr, offset: I) -> ptr */ + /* num overloads */ 4, + /* overloads */ OverloadIndex(404), }, { /* [157] */ + /* fn bufferArrayView[R : read, AS : uniform_or_storage, N : num, O : iu32, S : iu32](ptr, R>, offset: O, s: S) -> ptr */ + /* fn bufferArrayView[W : read_write, AS : workgroup_or_storage, N : num, O : iu32, S : iu32](ptr, W>, offset: O, s: S) -> ptr */ + /* fn bufferArrayView[R : read, AS : uniform_or_storage, O : iu32, S : iu32](ptr, offset: O, s: S) -> ptr */ + /* fn bufferArrayView[W : read_write, AS : workgroup_or_storage, O : iu32, S : iu32](ptr, offset: O, s: S) -> ptr */ + /* num overloads */ 4, + /* overloads */ OverloadIndex(408), + }, + { + /* [158] */ /* fn bufferLength[R : read, AS : uniform_or_storage, N : num](ptr, R>) -> u32 */ /* fn bufferLength[W : read_write, AS : workgroup_or_storage, N : num](ptr, W>) -> u32 */ /* fn bufferLength[R : read, AS : uniform_or_storage](ptr) -> u32 */ /* fn bufferLength[W : read_write, AS : workgroup_or_storage](ptr) -> u32 */ /* num overloads */ 4, - /* overloads */ OverloadIndex(602), - }, - { - /* [158] */ - /* fn print[T : concrete_scalar](T) */ - /* fn print[N : num, T : concrete_scalar](vec) */ - /* num overloads */ 2, - /* overloads */ OverloadIndex(774), + /* overloads */ OverloadIndex(412), }, { /* [159] */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ - /* fn hasResource>[K : iu32, I : iu32](index: I) -> bool */ + /* fn print[T : concrete_scalar](T) */ + /* fn print[N : num, T : concrete_scalar](vec) */ + /* num overloads */ 2, + /* overloads */ OverloadIndex(587), + }, + { + /* [160] */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ + /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ /* fn hasResource>[K : fiu32, I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ + /* fn hasResource[I : iu32](index: I) -> bool */ /* fn hasResource[I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : texture_filter, I : iu32](index: I) -> bool */ - /* fn hasResource>[F : sampler_filter, I : iu32](index: I) -> bool */ - /* num overloads */ 20, - /* overloads */ OverloadIndex(331), + /* num overloads */ 14, + /* overloads */ OverloadIndex(159), }, { - /* [160] */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ - /* fn getResource>[K : iu32, I : iu32](index: I) -> T */ + /* [161] */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ + /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ /* fn getResource>[K : fiu32, I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ /* fn getResource[I : iu32](index: I) -> T */ + /* fn getResource[I : iu32](index: I) -> S */ /* fn getResource[I : iu32](index: I) -> S */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : texture_filter, I : iu32](index: I) -> T */ - /* fn getResource>[F : sampler_filter, I : iu32](index: I) -> S */ - /* num overloads */ 20, - /* overloads */ OverloadIndex(351), + /* num overloads */ 14, + /* overloads */ OverloadIndex(173), }, }; @@ -21697,34 +16895,34 @@ constexpr IntrinsicInfo kUnaryOperators[] = { /* [0] */ /* op &[S : address_space, T, A : access](ref) -> ptr */ /* num overloads */ 1, - /* overloads */ OverloadIndex(836), + /* overloads */ OverloadIndex(649), }, { /* [1] */ /* op *[S : address_space, T, A : access](ptr) -> ref */ /* num overloads */ 1, - /* overloads */ OverloadIndex(837), + /* overloads */ OverloadIndex(650), }, { /* [2] */ /* op !(bool) -> bool */ /* op ![N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(776), + /* overloads */ OverloadIndex(589), }, { /* [3] */ /* op ~[T : ia_iu32](T) -> T */ /* op ~[T : ia_iu32, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(778), + /* overloads */ OverloadIndex(591), }, { /* [4] */ /* op -[T : fia_fi32_f16](T) -> T */ /* op -[T : fia_fi32_f16, N : num](vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(780), + /* overloads */ OverloadIndex(593), }, }; constexpr uint8_t kUnaryOperatorAnd = 0; @@ -21742,7 +16940,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op +[T : fia_fiu32_f16, N : num](T, vec) -> vec */ /* op +[T : fa_f32_f16, N : num, M : num](mat, mat) -> mat */ /* num overloads */ 5, - /* overloads */ OverloadIndex(584), + /* overloads */ OverloadIndex(386), }, { /* [1] */ @@ -21752,7 +16950,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op -[T : fia_fiu32_f16, N : num](T, vec) -> vec */ /* op -[T : fa_f32_f16, N : num, M : num](mat, mat) -> mat */ /* num overloads */ 5, - /* overloads */ OverloadIndex(589), + /* overloads */ OverloadIndex(391), }, { /* [2] */ @@ -21766,7 +16964,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op *[T : fa_f32_f16, C : num, R : num](vec, mat) -> vec */ /* op *[T : fa_f32_f16, K : num, C : num, R : num](mat, mat) -> mat */ /* num overloads */ 9, - /* overloads */ OverloadIndex(442), + /* overloads */ OverloadIndex(256), }, { /* [3] */ @@ -21775,7 +16973,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op /[T : fia_fiu32_f16, N : num](vec, T) -> vec */ /* op /[T : fia_fiu32_f16, N : num](T, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(606), + /* overloads */ OverloadIndex(416), }, { /* [4] */ @@ -21784,14 +16982,14 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op %[T : fia_fiu32_f16, N : num](vec, T) -> vec */ /* op %[T : fia_fiu32_f16, N : num](T, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(610), + /* overloads */ OverloadIndex(420), }, { /* [5] */ /* op ^[T : ia_iu32](T, T) -> T */ /* op ^[T : ia_iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(782), + /* overloads */ OverloadIndex(595), }, { /* [6] */ @@ -21800,7 +16998,7 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op &[T : ia_iu32](T, T) -> T */ /* op &[T : ia_iu32, N : num](vec, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(614), + /* overloads */ OverloadIndex(424), }, { /* [7] */ @@ -21809,75 +17007,75 @@ constexpr IntrinsicInfo kBinaryOperators[] = { /* op |[T : ia_iu32](T, T) -> T */ /* op |[T : ia_iu32, N : num](vec, vec) -> vec */ /* num overloads */ 4, - /* overloads */ OverloadIndex(618), + /* overloads */ OverloadIndex(428), }, { /* [8] */ /* op &&(bool, bool) -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(838), + /* overloads */ OverloadIndex(651), }, { /* [9] */ /* op ||(bool, bool) -> bool */ /* num overloads */ 1, - /* overloads */ OverloadIndex(839), + /* overloads */ OverloadIndex(652), }, { /* [10] */ /* op ==[T : scalar](T, T) -> bool */ /* op ==[T : scalar, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(784), + /* overloads */ OverloadIndex(597), }, { /* [11] */ /* op !=[T : scalar](T, T) -> bool */ /* op !=[T : scalar, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(786), + /* overloads */ OverloadIndex(599), }, { /* [12] */ /* op <[T : fia_fiu32_f16](T, T) -> bool */ /* op <[T : fia_fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(788), + /* overloads */ OverloadIndex(601), }, { /* [13] */ /* op >[T : fia_fiu32_f16](T, T) -> bool */ /* op >[T : fia_fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(790), + /* overloads */ OverloadIndex(603), }, { /* [14] */ /* op <=[T : fia_fiu32_f16](T, T) -> bool */ /* op <=[T : fia_fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(792), + /* overloads */ OverloadIndex(605), }, { /* [15] */ /* op >=[T : fia_fiu32_f16](T, T) -> bool */ /* op >=[T : fia_fiu32_f16, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(794), + /* overloads */ OverloadIndex(607), }, { /* [16] */ /* op <<[T : ia_iu32](T, u32) -> T */ /* op <<[T : ia_iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(796), + /* overloads */ OverloadIndex(609), }, { /* [17] */ /* op >>[T : ia_iu32](T, u32) -> T */ /* op >>[T : ia_iu32, N : num](vec, vec) -> vec */ /* num overloads */ 2, - /* overloads */ OverloadIndex(798), + /* overloads */ OverloadIndex(611), }, }; constexpr uint8_t kBinaryOperatorPlus = 0; @@ -21906,7 +17104,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor i32(i32) -> i32 */ /* conv i32[T : scalar_no_i32](T) -> i32 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(631), + /* overloads */ OverloadIndex(444), }, { /* [1] */ @@ -21914,7 +17112,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor u32(u32) -> u32 */ /* conv u32[T : scalar_no_u32](T) -> u32 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(634), + /* overloads */ OverloadIndex(447), }, { /* [2] */ @@ -21922,7 +17120,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor f32(f32) -> f32 */ /* conv f32[T : scalar_no_f32](T) -> f32 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(637), + /* overloads */ OverloadIndex(450), }, { /* [3] */ @@ -21930,7 +17128,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor f16(f16) -> f16 */ /* conv f16[T : scalar_no_f16](T) -> f16 */ /* num overloads */ 3, - /* overloads */ OverloadIndex(640), + /* overloads */ OverloadIndex(453), }, { /* [4] */ @@ -21938,7 +17136,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* ctor bool(bool) -> bool */ /* conv bool[T : scalar_no_bool](T) -> bool */ /* num overloads */ 3, - /* overloads */ OverloadIndex(643), + /* overloads */ OverloadIndex(456), }, { /* [5] */ @@ -21956,7 +17154,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv vec2[U : scalar_no_u32](vec2) -> vec2 */ /* conv vec2[U : scalar_no_bool](vec2) -> vec2 */ /* num overloads */ 13, - /* overloads */ OverloadIndex(419), + /* overloads */ OverloadIndex(187), }, { /* [6] */ @@ -21978,7 +17176,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv vec3[U : scalar_no_u32](vec3) -> vec3 */ /* conv vec3[U : scalar_no_bool](vec3) -> vec3 */ /* num overloads */ 17, - /* overloads */ OverloadIndex(371), + /* overloads */ OverloadIndex(97), }, { /* [7] */ @@ -22008,7 +17206,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv vec4[U : scalar_no_u32](vec4) -> vec4 */ /* conv vec4[U : scalar_no_bool](vec4) -> vec4 */ /* num overloads */ 25, - /* overloads */ OverloadIndex(306), + /* overloads */ OverloadIndex(72), }, { /* [8] */ @@ -22022,7 +17220,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat2x2(mat2x2) -> mat2x2 */ /* conv mat2x2(mat2x2) -> mat2x2 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(451), + /* overloads */ OverloadIndex(265), }, { /* [9] */ @@ -22036,7 +17234,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat2x3(mat2x3) -> mat2x3 */ /* conv mat2x3(mat2x3) -> mat2x3 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(460), + /* overloads */ OverloadIndex(274), }, { /* [10] */ @@ -22050,7 +17248,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat2x4(mat2x4) -> mat2x4 */ /* conv mat2x4(mat2x4) -> mat2x4 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(469), + /* overloads */ OverloadIndex(283), }, { /* [11] */ @@ -22064,7 +17262,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat3x2(mat3x2) -> mat3x2 */ /* conv mat3x2(mat3x2) -> mat3x2 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(478), + /* overloads */ OverloadIndex(292), }, { /* [12] */ @@ -22078,7 +17276,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat3x3(mat3x3) -> mat3x3 */ /* conv mat3x3(mat3x3) -> mat3x3 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(487), + /* overloads */ OverloadIndex(301), }, { /* [13] */ @@ -22092,7 +17290,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat3x4(mat3x4) -> mat3x4 */ /* conv mat3x4(mat3x4) -> mat3x4 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(496), + /* overloads */ OverloadIndex(310), }, { /* [14] */ @@ -22106,7 +17304,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat4x2(mat4x2) -> mat4x2 */ /* conv mat4x2(mat4x2) -> mat4x2 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(505), + /* overloads */ OverloadIndex(319), }, { /* [15] */ @@ -22120,7 +17318,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat4x3(mat4x3) -> mat4x3 */ /* conv mat4x3(mat4x3) -> mat4x3 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(514), + /* overloads */ OverloadIndex(328), }, { /* [16] */ @@ -22134,7 +17332,7 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { /* conv mat4x4(mat4x4) -> mat4x4 */ /* conv mat4x4(mat4x4) -> mat4x4 */ /* num overloads */ 9, - /* overloads */ OverloadIndex(523), + /* overloads */ OverloadIndex(337), }, }; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/ir/atomic_vec2u_to_from_u64.cc b/3rdparty/dawn/src/tint/lang/wgsl/ir/atomic_vec2u_to_from_u64.cc index a716c0ab6..74ff5c1f0 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/ir/atomic_vec2u_to_from_u64.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/ir/atomic_vec2u_to_from_u64.cc @@ -171,10 +171,11 @@ struct State { TINT_ASSERT(as_inst_result); auto* as_inst = as_inst_result->Instruction(); TINT_ASSERT(as_inst); - auto* as_bitcast = as_inst->As(); + auto* as_bitcast = as_inst->As(); TINT_ASSERT(as_bitcast); + TINT_ASSERT(as_bitcast->Func() == core::BuiltinFn::kBitcast); TINT_ASSERT(as_bitcast->Result()->NumUsages() == 1); - param_u64 = as_bitcast->Val(); + param_u64 = as_bitcast->Args()[0]; as_bitcast->Destroy(); wgsl::BuiltinFn wgsl_fn = call->Func() == core::BuiltinFn::kAtomicStoreMax @@ -247,16 +248,7 @@ struct State { } // namespace Result AtomicVec2uToFromU64(core::ir::Module& ir, AtomicVec2uU64Direction direction) { - auto result = - core::ir::ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - }, - "transform::AtomicVec2uToFromU64"); - if (result != Success) { - return result; - } + core::ir::AssertValid(ir, "before transform::AtomicVec2uToFromU64"); State{ir, direction}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/wgsl/ir/builtin_call.cc b/3rdparty/dawn/src/tint/lang/wgsl/ir/builtin_call.cc index 701cc192a..fe6fcde3d 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/ir/builtin_call.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/ir/builtin_call.cc @@ -27,8 +27,6 @@ #include "src/tint/lang/wgsl/ir/builtin_call.h" -#include - #include "src/tint/lang/core/ir/clone_context.h" #include "src/tint/lang/core/ir/module.h" #include "src/tint/utils/ice/ice.h" @@ -51,7 +49,9 @@ BuiltinCall::~BuiltinCall() = default; BuiltinCall* BuiltinCall::Clone(core::ir::CloneContext& ctx) { auto* new_result = ctx.Clone(Result()); auto new_args = ctx.Clone(Args()); - return ctx.ir.CreateInstruction(new_result, fn_, new_args); + auto* cloned = ctx.ir.CreateInstruction(new_result, fn_, new_args); + cloned->SetExplicitTemplateParams(ExplicitTemplateParams()); + return cloned; } } // namespace tint::wgsl::ir diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.cc b/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.cc index feaae180e..069ac29c4 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.cc @@ -28,9 +28,7 @@ #include "src/tint/lang/wgsl/resolver/dependency_graph.h" #include -#include #include -#include #include "src/tint/lang/core/enums.h" #include "src/tint/lang/wgsl/ast/alias.h" @@ -72,8 +70,6 @@ #include "src/tint/lang/wgsl/ast/variable_decl_statement.h" #include "src/tint/lang/wgsl/ast/while_statement.h" #include "src/tint/lang/wgsl/ast/workgroup_attribute.h" -#include "src/tint/lang/wgsl/sem/builtin_fn.h" -#include "src/tint/utils/containers/map.h" #include "src/tint/utils/containers/scope_stack.h" #include "src/tint/utils/containers/unique_vector.h" #include "src/tint/utils/macros/compiler.h" @@ -82,9 +78,6 @@ #include "src/tint/utils/memory/block_allocator.h" #include "src/tint/utils/rtti/switch.h" #include "src/tint/utils/text/string.h" -#include "src/tint/utils/text/string_stream.h" - -#define TINT_DUMP_DEPENDENCY_GRAPH 0 namespace tint::resolver { namespace { @@ -92,12 +85,6 @@ namespace { // Forward declaration struct Global; -/// Dependency describes how one global depends on another global -struct DependencyInfo { - /// The source of the symbol that forms the dependency - Source source; -}; - /// DependencyEdge describes the two Globals used to define a dependency /// relationship. struct DependencyEdge { @@ -113,8 +100,8 @@ struct DependencyEdge { bool operator==(const DependencyEdge& rhs) const { return from == rhs.from && to == rhs.to; } }; -/// A map of DependencyEdge to DependencyInfo -using DependencyEdges = Hashmap; +/// A map of DependencyEdge to Source +using DependencyEdges = Hashmap; /// Global describes a module-scope variable, type or function. struct Global { @@ -234,9 +221,6 @@ class DependencyScanner { TINT_DEFER(scope_stack_.Pop()); for (auto* param : func->params) { - if (auto shadows = scope_stack_.Get(param->name->symbol)) { - graph_.shadows.Add(param, shadows); - } Declare(param->name->symbol, param); } if (func->body) { @@ -308,9 +292,6 @@ class DependencyScanner { } }, [&](const ast::VariableDeclStatement* v) { - if (auto* shadows = scope_stack_.Get(v->variable->name->symbol)) { - graph_.shadows.Add(v->variable, shadows); - } TraverseVariable(v->variable); Declare(v->variable->name->symbol, v->variable); }, @@ -397,7 +378,7 @@ class DependencyScanner { } /// The type of builtin that a symbol could represent. - enum class BuiltinType { + enum class Kind : uint8_t { /// No builtin matched kNone = 0, /// Builtin function @@ -410,10 +391,8 @@ class DependencyScanner { kTexelFormat, /// Access kAccess, - /// Texture filterable - kTextureFilterable, - /// Sampler filtering - kSamplerFiltering, + /// Majorness + kMajorness, }; /// BuiltinInfo stores information about the builtin that a symbol represents. @@ -424,16 +403,15 @@ class DependencyScanner { return std::get(value); } - BuiltinType type = BuiltinType::kNone; + Kind type = Kind::kNone; std::variant - value = {}; + core::Majorness> + value{}; }; /// Get the builtin info for a given symbol. @@ -443,31 +421,27 @@ class DependencyScanner { return builtin_info_map.GetOrAdd(symbol, [&] { if (auto builtin_fn = wgsl::ParseBuiltinFn(symbol.NameView()); builtin_fn != wgsl::BuiltinFn::kNone) { - return BuiltinInfo{BuiltinType::kFunction, builtin_fn}; + return BuiltinInfo{Kind::kFunction, builtin_fn}; } if (auto builtin_ty = core::ParseBuiltinType(symbol.NameView()); builtin_ty != core::BuiltinType::kUndefined) { - return BuiltinInfo{BuiltinType::kBuiltin, builtin_ty}; + return BuiltinInfo{Kind::kBuiltin, builtin_ty}; } if (auto addr = core::ParseAddressSpace(symbol.NameView()); addr != core::AddressSpace::kUndefined) { - return BuiltinInfo{BuiltinType::kAddressSpace, addr}; + return BuiltinInfo{Kind::kAddressSpace, addr}; } if (auto fmt = core::ParseTexelFormat(symbol.NameView()); fmt != core::TexelFormat::kUndefined) { - return BuiltinInfo{BuiltinType::kTexelFormat, fmt}; + return BuiltinInfo{Kind::kTexelFormat, fmt}; } if (auto access = core::ParseAccess(symbol.NameView()); access != core::Access::kUndefined) { - return BuiltinInfo{BuiltinType::kAccess, access}; + return BuiltinInfo{Kind::kAccess, access}; } - if (auto filterable = core::ParseTextureFilterable(symbol.NameView()); - filterable != core::TextureFilterable::kUndefined) { - return BuiltinInfo{BuiltinType::kTextureFilterable, filterable}; - } - if (auto filterable = core::ParseSamplerFiltering(symbol.NameView()); - filterable != core::SamplerFiltering::kUndefined) { - return BuiltinInfo{BuiltinType::kSamplerFiltering, filterable}; + if (auto major = core::ParseMajorness(symbol.NameView()); + major != core::Majorness::kUndefined) { + return BuiltinInfo{Kind::kMajorness, major}; } return BuiltinInfo{}; }); @@ -479,45 +453,40 @@ class DependencyScanner { if (!resolved) { auto builtin_info = GetBuiltinInfo(to); switch (builtin_info.type) { - case BuiltinType::kNone: + case Kind::kNone: graph_.resolved_identifiers.Add( from, ResolvedIdentifier::UnresolvedIdentifier{to.Name()}); break; - case BuiltinType::kFunction: + case Kind::kFunction: graph_.resolved_identifiers.Add( from, ResolvedIdentifier(builtin_info.Value())); break; - case BuiltinType::kBuiltin: + case Kind::kBuiltin: graph_.resolved_identifiers.Add( from, ResolvedIdentifier(builtin_info.Value())); break; - case BuiltinType::kAddressSpace: + case Kind::kAddressSpace: graph_.resolved_identifiers.Add( from, ResolvedIdentifier(builtin_info.Value())); break; - case BuiltinType::kTexelFormat: + case Kind::kTexelFormat: graph_.resolved_identifiers.Add( from, ResolvedIdentifier(builtin_info.Value())); break; - case BuiltinType::kAccess: + case Kind::kAccess: graph_.resolved_identifiers.Add( from, ResolvedIdentifier(builtin_info.Value())); break; - case BuiltinType::kTextureFilterable: + case Kind::kMajorness: graph_.resolved_identifiers.Add( - from, ResolvedIdentifier(builtin_info.Value())); - break; - case BuiltinType::kSamplerFiltering: - graph_.resolved_identifiers.Add( - from, ResolvedIdentifier(builtin_info.Value())); + from, ResolvedIdentifier(builtin_info.Value())); break; } return; } if (auto global = globals_.Get(to); global && (*global)->node == resolved) { - if (dependency_edges_.Add(DependencyEdge{current_global_, *global}, - DependencyInfo{from->source})) { + if (dependency_edges_.Add(DependencyEdge{current_global_, *global}, from->source)) { current_global_->deps.Push(*global); } } @@ -525,7 +494,6 @@ class DependencyScanner { graph_.resolved_identifiers.Add(from, ResolvedIdentifier(resolved)); } - using VariableMap = Hashmap; const GlobalMap& globals_; diag::List& diagnostics_; DependencyGraph& graph_; @@ -561,9 +529,6 @@ struct DependencyAnalysis { // Sort the globals into dependency order SortGlobals(); - // Dump the dependency graph if TINT_DUMP_DEPENDENCY_GRAPH is non-zero - DumpDependencyGraph(); - graph_.ordered_globals = sorted_.Release(); return !diagnostics_.ContainsErrors(); @@ -726,18 +691,6 @@ struct DependencyAnalysis { } } - /// DepInfoFor() looks up the global dependency information for the dependency - /// of global `from` depending on `to`. - /// @note will raise an ICE if the edge is not found. - DependencyInfo DepInfoFor(const Global* from, const Global* to) const { - auto info = dependency_edges_.Get(DependencyEdge{from, to}); - if (DAWN_LIKELY(info)) { - return *info; - } - TINT_ICE() << "failed to find dependency info for edge: '" << NameOf(from->node) << "' -> '" - << NameOf(to->node) << "'"; - } - /// CyclicDependencyFound() emits an error diagnostic for a cyclic dependency. /// @param root is the global that starts the cyclic dependency, which must be /// found in `stack`. @@ -761,36 +714,19 @@ struct DependencyAnalysis { for (size_t i = loop_start; i < stack.Length(); i++) { auto* from = stack[i]; auto* to = (i + 1 < stack.Length()) ? stack[i + 1] : stack[loop_start]; - auto info = DepInfoFor(from, to); - AddNote(diagnostics_, info.source) + + auto source = dependency_edges_.Get(DependencyEdge{from, to}); + if (DAWN_UNLIKELY(!source)) { + TINT_ICE() << "failed to find dependency info for edge: '" << NameOf(from->node) + << "' -> '" << NameOf(to->node) << "'"; + } + + AddNote(diagnostics_, *source) << KindOf(from->node) + " '" << NameOf(from->node) << "' references " << KindOf(to->node) << " '" << NameOf(to->node) << "' here"; } } - void DumpDependencyGraph() { -#if TINT_DUMP_DEPENDENCY_GRAPH == 0 - if ((true)) { - return; - } -#endif // TINT_DUMP_DEPENDENCY_GRAPH - printf("=========================\n"); - printf("------ declaration ------ \n"); - for (auto* global : declaration_order_) { - printf("%s\n", NameOf(global->node).c_str()); - } - printf("------ dependencies ------ \n"); - for (auto* node : sorted_) { - auto symbol = SymbolOf(node); - auto* global = *globals_.Get(symbol); - printf("%s depends on:\n", symbol.Name().c_str()); - for (auto* dep : global->deps) { - printf(" %s\n", NameOf(dep->node).c_str()); - } - } - printf("=========================\n"); - } - /// Program diagnostics diag::List& diagnostics_; @@ -803,7 +739,7 @@ struct DependencyAnalysis { /// Global map, keyed by name. Populated by GatherGlobals(). GlobalMap globals_; - /// Map of DependencyEdge to DependencyInfo. Populated by DetermineDependencies(). + /// Map of DependencyEdge to Source. Populated by DetermineDependencies(). DependencyEdges dependency_edges_; /// Globals in declaration order. Populated by GatherGlobals(). @@ -868,6 +804,9 @@ std::string ResolvedIdentifier::String() const { if (auto fmt = TexelFormat(); fmt != core::TexelFormat::kUndefined) { return "texel format '" + tint::ToString(fmt) + "'"; } + if (auto major = Majorness(); major != core::Majorness::kUndefined) { + return "majorness '" + tint::ToString(major) + "'"; + } if (auto* unresolved = Unresolved()) { return "unresolved identifier '" + unresolved->name + "'"; } diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.h b/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.h index 059011d7d..b9aa77e84 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/dependency_graph.h @@ -29,7 +29,6 @@ #define SRC_TINT_LANG_WGSL_RESOLVER_DEPENDENCY_GRAPH_H_ #include -#include #include "src/tint/lang/core/enums.h" #include "src/tint/lang/wgsl/ast/module.h" @@ -50,6 +49,7 @@ namespace tint::resolver { /// - core::AddressSpace /// - core::BuiltinType /// - core::TexelFormat +/// - core::Majorness class ResolvedIdentifier { public: /// UnresolvedIdentifier is the variant value used to represent an unresolved identifier @@ -124,22 +124,11 @@ class ResolvedIdentifier { return core::TexelFormat::kUndefined; } - /// @return the texture filterable if the ResolvedIdentifier holds type::TextureFilterable, - /// otherwise core::TextureFilterable::kUndefined - core::TextureFilterable TextureFilterable() const { - if (auto n = std::get_if(&value_)) { + core::Majorness Majorness() const { + if (auto n = std::get_if(&value_)) { return *n; } - return core::TextureFilterable::kUndefined; - } - - /// @return the texture filterable if the ResolvedIdentifier holds type::SamplerFiltering, - /// otherwise core::SamplerFiltering::kUndefined - core::SamplerFiltering SamplerFiltering() const { - if (auto n = std::get_if(&value_)) { - return *n; - } - return core::SamplerFiltering::kUndefined; + return core::Majorness::kUndefined; } /// @param value the value to compare the ResolvedIdentifier to @@ -170,8 +159,7 @@ class ResolvedIdentifier { core::AddressSpace, core::BuiltinType, core::TexelFormat, - core::TextureFilterable, - core::SamplerFiltering> + core::Majorness> value_; }; @@ -198,12 +186,6 @@ struct DependencyGraph { /// Map of ast::Identifier to a ResolvedIdentifier Hashmap resolved_identifiers; - - /// Map of ast::Variable to a type, function, or variable that is shadowed by - /// the variable key. A declaration (X) shadows another (Y) if X and Y use - /// the same symbol, and X is declared in a sub-scope of the scope that - /// declares Y. - Hashmap shadows; }; } // namespace tint::resolver diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.cc b/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.cc index 1957a6124..4c4a83419 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.cc @@ -32,7 +32,7 @@ #include #include -#include "src/tint/lang/core/constant/scalar.h" +#include "src/tint/lang/core/constant/scalar.h" // IWYU pragma: export #include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/fluent_types.h" #include "src/tint/lang/core/type/abstract_float.h" @@ -123,6 +123,13 @@ using namespace tint::core::fluent_types; // NOLINT namespace tint::resolver { namespace { +#define TINT_RET_IF(expr) \ + do { \ + if ((expr)) { \ + return {}; \ + } \ + } while (false) + /// ICE() is a wrapper around TINT_ICE() that includes a prefixed source location #define ICE(SOURCE) TINT_ICE() << SOURCE << (SOURCE.file ? ": " : "") @@ -151,27 +158,21 @@ Resolver::Resolver(ProgramBuilder* builder, const wgsl::AllowedFeatures& allowed Resolver::~Resolver() = default; bool Resolver::Resolve() { - if (diagnostics_.ContainsErrors()) { - return false; - } + TINT_RET_IF(diagnostics_.ContainsErrors()); b.Sem().Reserve(b.LastAllocatedNodeID()); // Pre-allocate the marked bitset with the total number of AST nodes. marked_.Resize(b.ASTNodes().Count()); - if (!DependencyGraph::Build(b.AST(), diagnostics_, dependencies_)) { - return false; - } + TINT_RET_IF(!DependencyGraph::Build(b.AST(), diagnostics_, dependencies_)); bool result = ResolveInternal(); TINT_ASSERT(result || diagnostics_.ContainsErrors()) << "resolving failed, but no error was raised"; - if (!validator_.Enables(b.AST().Enables())) { - return false; - } + TINT_RET_IF(!validator_.Enables(b.AST().Enables())); // Create the semantic module. Don't be tempted to std::move() these, they're used below. auto* mod = b.create(dependencies_.ordered_globals, enabled_extensions_); @@ -184,9 +185,7 @@ bool Resolver::Resolve() { // Run the uniformity analysis, which requires a complete semantic module. const bool subgroup_uniformity = allowed_features_.features.contains(wgsl::LanguageFeature::kSubgroupUniformity); - if (!AnalyzeUniformity(b, dependencies_, subgroup_uniformity)) { - return false; - } + TINT_RET_IF(!AnalyzeUniformity(b, dependencies_, subgroup_uniformity)); } return result; @@ -216,24 +215,11 @@ bool Resolver::ResolveInternal() { } } - if (!AllocateOverridableConstantIds()) { - return false; - } - - SetShadows(); - - if (!validator_.DiagnosticControls(diagnostic_controls, "directive", - DiagnosticDuplicates::kAllowed)) { - return false; - } - - if (!validator_.PipelineStages(entry_points_)) { - return false; - } - - if (!validator_.ModuleScopeVarUsages(entry_points_)) { - return false; - } + TINT_RET_IF(!AllocateOverridableConstantIds()); + TINT_RET_IF(!validator_.DiagnosticControls(diagnostic_controls, "directive", + DiagnosticDuplicates::kAllowed)); + TINT_RET_IF(!validator_.PipelineStages(entry_points_)); + TINT_RET_IF(!validator_.ModuleScopeVarUsages(entry_points_)); bool result = true; for (auto* node : b.ASTNodes().Objects()) { @@ -267,9 +253,8 @@ sem::Variable* Resolver::Let(const ast::Let* v) { // If the variable has a declared type, resolve it. if (v->type) { auto* ty = Type(v->type); - if (DAWN_UNLIKELY(!ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); + sem->SetType(ty); } @@ -280,14 +265,13 @@ sem::Variable* Resolver::Let(const ast::Let* v) { } if (DAWN_UNLIKELY(!v->initializer)) { - AddError(v->source) << style::Keyword("let") << " declaration must have an initializer"; + AddError(v) << style::Keyword("let") << " declaration must have an initializer"; return nullptr; } auto* rhs = Load(Materialize(ValueExpression(v->initializer), sem->Type())); - if (DAWN_UNLIKELY(!rhs)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!rhs)); + sem->SetInitializer(rhs); // If the variable has no declared type, infer it from the RHS @@ -295,14 +279,12 @@ sem::Variable* Resolver::Let(const ast::Let* v) { sem->SetType(rhs->Type()->UnwrapRef()); // Implicit load of RHS } - if (DAWN_UNLIKELY(rhs && !validator_.VariableInitializer(v, sem->Type(), rhs))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(rhs && !validator_.VariableInitializer(v, sem->Type(), rhs))); if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, const_cast(sem->Type()), v->source)) { - AddNote(v->source) << "while instantiating " << style::Keyword("let ") - << style::Variable(v->name->symbol.NameView()); + AddNote(v) << "while instantiating " << style::Keyword("let ") + << style::Variable(v->name->symbol.NameView()); return nullptr; } @@ -325,9 +307,7 @@ sem::Variable* Resolver::Override(const ast::Override* v) { const core::type::Type* ty = nullptr; if (v->type) { ty = Type(v->type); - if (!ty) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); } // Does the variable have an initializer? @@ -339,9 +319,8 @@ sem::Variable* Resolver::Override(const ast::Override* v) { "override initializer"}; TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); init = Materialize(ValueExpression(v->initializer), ty); - if (DAWN_UNLIKELY(!init)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!init)); + sem->SetInitializer(init); // If the variable has no declared type, infer it from the initializer @@ -349,19 +328,17 @@ sem::Variable* Resolver::Override(const ast::Override* v) { ty = init->Type(); } } else if (!ty) { - AddError(v->source) << "override declaration requires a type or initializer"; + AddError(v) << "override declaration requires a type or initializer"; return nullptr; } sem->SetType(ty); - if (init && !validator_.VariableInitializer(v, ty, init)) { - return nullptr; - } + TINT_RET_IF(init && !validator_.VariableInitializer(v, ty, init)); if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, const_cast(ty), v->source)) { - AddNote(v->source) << "while instantiating " << style::Keyword("override ") - << style::Variable(v->name->symbol.NameView()); + AddNote(v) << "while instantiating " << style::Keyword("override ") + << style::Variable(v->name->symbol.NameView()); return nullptr; } @@ -369,16 +346,15 @@ sem::Variable* Resolver::Override(const ast::Override* v) { Mark(attribute); bool ok = Switch( attribute, // - [&](const ast::IdAttribute* attr) { + [&](const ast::IdAttribute* attr) -> bool { ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "@id"}; TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); auto* materialized = Materialize(ValueExpression(attr->expr)); - if (!materialized) { - return false; - } + TINT_RET_IF(!materialized); + if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) + AddError(attr) << style::Attribute("@id") << " must be an " << style::Type("i32") << " or " << style::Type("u32") << " value"; return false; @@ -387,14 +363,12 @@ sem::Variable* Resolver::Override(const ast::Override* v) { auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value < 0) { - AddError(attr->source) - << style::Attribute("@id") << " value must be non-negative"; + AddError(attr) << style::Attribute("@id") << " value must be non-negative"; return false; } if (value > std::numeric_limits::max()) { - AddError(attr->source) - << style::Attribute("@id") << " value must be between 0 and " - << std::numeric_limits::max(); + AddError(attr) << style::Attribute("@id") << " value must be between 0 and " + << std::numeric_limits::max(); return false; } @@ -410,9 +384,8 @@ sem::Variable* Resolver::Override(const ast::Override* v) { StyledText{} << style::Keyword("override") << " declaration"); return false; }); - if (!ok) { - return nullptr; - } + + TINT_RET_IF(DAWN_UNLIKELY(!ok)); } return sem; @@ -438,22 +411,18 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) { attribute, StyledText{} << style::Keyword("const") << " declaration"); return false; }); - if (!ok) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ok)); } if (DAWN_UNLIKELY(!c->initializer)) { - AddError(c->source) << "'const' declaration must have an initializer"; + AddError(c) << "'const' declaration must have an initializer"; return nullptr; } ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "const initializer"}; TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); const auto* init = ValueExpression(c->initializer); - if (DAWN_UNLIKELY(!init)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!init)); // Note: RHS must be a const expression, which excludes references. // So there's no need to load or unwrap references here. @@ -462,17 +431,13 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) { const core::type::Type* ty = nullptr; if (c->type) { ty = Type(c->type); - if (DAWN_UNLIKELY(!ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); } if (ty) { // If an explicit type was specified, materialize to that type init = Materialize(init, ty); - if (DAWN_UNLIKELY(!init)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!init)); } else { // If no type was specified, infer it from the RHS ty = init->Type(); @@ -483,13 +448,11 @@ sem::Variable* Resolver::Const(const ast::Const* c, bool is_global) { sem->SetConstantValue(init->ConstantValue()); sem->SetType(ty); - if (!validator_.VariableInitializer(c, ty, init)) { - return nullptr; - } + TINT_RET_IF(!validator_.VariableInitializer(c, ty, init)); if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, const_cast(ty), c->source)) { - AddNote(c->source) << "while instantiating 'const' " << c->name->symbol.NameView(); + AddNote(c) << "while instantiating 'const' " << c->name->symbol.NameView(); return nullptr; } @@ -525,9 +488,7 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) { const core::type::Type* storage_ty = nullptr; if (auto ty = var->type) { storage_ty = Type(ty); - if (DAWN_UNLIKELY(!storage_ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!storage_ty)); } // Does the variable have a initializer? @@ -539,9 +500,8 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) { TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); auto* init = Load(Materialize(ValueExpression(var->initializer), storage_ty)); - if (DAWN_UNLIKELY(!init)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!init)); + sem->SetInitializer(init); // If the variable has no declared type, infer it from the RHS @@ -551,15 +511,14 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) { } if (!storage_ty) { - AddError(var->source) << "var declaration requires a type or initializer"; + AddError(var) << "var declaration requires a type or initializer"; return nullptr; } if (var->declared_address_space) { auto space = AddressSpaceExpression(var->declared_address_space); - if (DAWN_UNLIKELY(!space)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!space)); + sem->SetAddressSpace(space->Value()); } else { // No declared address space. Infer from usage / type. @@ -574,16 +533,14 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) { } if (!is_global && sem->AddressSpace() != core::AddressSpace::kFunction) { - AddError(var->source) - << "function-scope 'var' declaration must use 'function' address space"; + AddError(var) << "function-scope 'var' declaration must use 'function' address space"; return nullptr; } if (var->declared_access) { auto expr = AccessExpression(var->declared_access); - if (!expr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!expr)); + sem->SetAccess(expr->Value()); } else { sem->SetAccess(DefaultAccessForAddressSpace(sem->AddressSpace())); @@ -591,15 +548,13 @@ sem::Variable* Resolver::Var(const ast::Var* var, bool is_global) { sem->SetType(b.create(sem->AddressSpace(), storage_ty, sem->Access())); - if (sem->Initializer() && - !validator_.VariableInitializer(var, storage_ty, sem->Initializer())) { - return nullptr; - } + TINT_RET_IF(sem->Initializer() && + !validator_.VariableInitializer(var, storage_ty, sem->Initializer())); if (!ApplyAddressSpaceUsageToType(sem->AddressSpace(), const_cast(sem->Type()), var->type ? var->type->source : var->source)) { - AddNote(var->source) << "while instantiating 'var' " << var->name->symbol.NameView(); + AddNote(var) << "while instantiating 'var' " << var->name->symbol.NameView(); return nullptr; } @@ -674,8 +629,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, b.Sem().Add(param, sem); auto add_note = [&] { - AddNote(param->source) << "while instantiating parameter " - << param->name->symbol.NameView(); + AddNote(param) << "while instantiating parameter " << param->name->symbol.NameView(); }; if (func->IsEntryPoint()) { @@ -683,19 +637,17 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, Mark(attribute); bool ok = Switch( attribute, // - [&](const ast::LocationAttribute* attr) { + [&](const ast::LocationAttribute* attr) -> bool { auto value = LocationAttribute(attr); - if (DAWN_UNLIKELY(value != Success)) { - return false; - } + TINT_RET_IF(DAWN_UNLIKELY(value != Success)); + sem->Attributes().location = value.Get(); return true; }, - [&](const ast::ColorAttribute* attr) { + [&](const ast::ColorAttribute* attr) -> bool { auto value = ColorAttribute(attr); - if (DAWN_UNLIKELY(value != Success)) { - return false; - } + TINT_RET_IF(DAWN_UNLIKELY(value != Success)); + sem->Attributes().color = value.Get(); return true; }, @@ -708,9 +660,8 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, ErrorInvalidAttribute(attribute, StyledText{} << "function parameters"); return false; }); - if (!ok) { - return nullptr; - } + + TINT_RET_IF(DAWN_UNLIKELY(!ok)); } } else if (!param->attributes.IsEmpty()) { auto& attribute = param->attributes[0]; @@ -723,14 +674,11 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, return nullptr; } - if (!validator_.NoDuplicateAttributes(param->attributes)) { - return nullptr; - } + TINT_RET_IF(!validator_.NoDuplicateAttributes(param->attributes)); const core::type::Type* ty = Type(param->type); - if (DAWN_UNLIKELY(!ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); + sem->SetType(ty); if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, ty, param->type->source)) { @@ -738,9 +686,7 @@ sem::Parameter* Resolver::Parameter(const ast::Parameter* param, return nullptr; } - if (!validator_.Parameter(sem)) { - return nullptr; - } + TINT_RET_IF(!validator_.Parameter(sem)); return sem; } @@ -794,8 +740,7 @@ bool Resolver::AllocateOverridableConstantIds() { increment_next_id(); } if (ids_exhausted) { - AddError(decl->source) - << "number of 'override' variables exceeded limit of " << kLimit; + AddError(decl) << "number of 'override' variables exceeded limit of " << kLimit; return false; } id = next_id; @@ -807,36 +752,11 @@ bool Resolver::AllocateOverridableConstantIds() { return true; } -void Resolver::SetShadows() { - for (auto& it : dependencies_.shadows) { - CastableBase* shadowed = sem_.Get(it.value); - if (DAWN_UNLIKELY(!shadowed)) { - ICE(it.value->source) << "AST node '" << it.value->TypeInfo().name - << "' had no semantic info\n" - << "Pointer: " << it.value; - } - - Switch( - sem_.Get(it.key.Value()), // - [&](sem::LocalVariable* local) { local->SetShadows(shadowed); }, - [&](sem::Parameter* param) { param->SetShadows(shadowed); }); - } -} - sem::GlobalVariable* Resolver::GlobalVariable(const ast::Variable* v) { auto* sem = As(Variable(v, /* is_global */ true)); - if (!sem) { - return nullptr; - } - - if (!validator_.NoDuplicateAttributes(v->attributes)) { - return nullptr; - } - - if (!validator_.GlobalVariable(sem, override_ids_)) { - return nullptr; - } - + TINT_RET_IF(DAWN_UNLIKELY(!sem)); + TINT_RET_IF(!validator_.NoDuplicateAttributes(v->attributes)); + TINT_RET_IF(!validator_.GlobalVariable(sem, override_ids_)); return sem; } @@ -844,17 +764,16 @@ sem::Statement* Resolver::ConstAssert(const ast::ConstAssert* assertion) { ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "const assertion"}; TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); auto* expr = ValueExpression(assertion->condition); - if (!expr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!expr)); + auto* cond = expr->ConstantValue(); if (auto* ty = cond->Type(); !ty->Is()) { - AddError(assertion->condition->source) + AddError(assertion->condition) << "const assertion condition must be a bool, got '" << ty->FriendlyName() << "'"; return nullptr; } if (!cond->ValueAs()) { - AddError(assertion->source) << "const assertion failed"; + AddError(assertion) << "const assertion failed"; return nullptr; } auto* sem = b.create(assertion, current_compound_statement_, current_function_); @@ -884,19 +803,17 @@ sem::Function* Resolver::Function(const ast::Function* decl) { [&](const ast::DiagnosticAttribute* attr) { return DiagnosticAttribute(attr); }, [&](const ast::StageAttribute* attr) { return StageAttribute(attr); }, [&](const ast::MustUseAttribute* attr) { return MustUseAttribute(attr); }, - [&](const ast::WorkgroupAttribute* attr) { + [&](const ast::WorkgroupAttribute* attr) -> bool { auto value = WorkgroupAttribute(attr); - if (value != Success) { - return false; - } + TINT_RET_IF(value != Success); + func->SetWorkgroupSize(value.Get()); return true; }, - [&](const ast::SubgroupSizeAttribute* attr) { + [&](const ast::SubgroupSizeAttribute* attr) -> bool { auto value = SubgroupSizeAttribute(attr); - if (value != Success) { - return false; - } + TINT_RET_IF(value != Success); + func->SetSubgroupSize(value.Get()); return true; }, @@ -904,33 +821,28 @@ sem::Function* Resolver::Function(const ast::Function* decl) { ErrorInvalidAttribute(attribute, StyledText{} << "functions"); return false; }); - if (!ok) { - return nullptr; - } - } - if (!validator_.NoDuplicateAttributes(decl->attributes)) { - return nullptr; + + TINT_RET_IF(DAWN_UNLIKELY(!ok)); } + TINT_RET_IF(!validator_.NoDuplicateAttributes(decl->attributes)); // Resolve all the parameters uint32_t parameter_index = 0; - Hashmap parameter_names; + Hashmap parameter_names; for (auto* param : decl->params) { Mark(param); { // Check the parameter name is unique for the function - if (auto added = parameter_names.Add(param->name->symbol, param->source); !added) { + if (auto added = parameter_names.Add(param->name->symbol, param); !added) { auto name = param->name->symbol.NameView(); - AddError(param->source) << "redefinition of parameter '" << name << "'"; + AddError(param) << "redefinition of parameter '" << name << "'"; AddNote(added.value) << "previous definition is here"; return nullptr; } } auto* p = Parameter(param, decl, parameter_index++); - if (!p) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!p)); func->AddParameter(p); @@ -956,9 +868,7 @@ sem::Function* Resolver::Function(const ast::Function* decl) { const core::type::Type* return_type = nullptr; if (auto ty = decl->return_type) { return_type = Type(ty); - if (!return_type) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!return_type)); } else { return_type = b.create(); } @@ -1006,16 +916,14 @@ sem::Function* Resolver::Function(const ast::Function* decl) { attribute, StyledText{} << "non-entry point function return types"); return false; }); - if (!ok) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ok)); } } if (auto* str = const_cast(return_type->As())) { if (!ApplyAddressSpaceUsageToType(core::AddressSpace::kUndefined, str, decl->return_type->source)) { - AddNote(decl->return_type->source) + AddNote(decl->return_type) << "while instantiating return type for " << decl->name->symbol.NameView(); return nullptr; } @@ -1049,9 +957,8 @@ sem::Function* Resolver::Function(const ast::Function* decl) { } auto* body = StatementScope(decl->body, b.create(func), [&] { return Statements(decl->body->statements); }); - if (!body) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!body)); + func->Behaviors() = body->Behaviors(); if (func->Behaviors().Contains(sem::Behavior::kReturn)) { // https://www.w3.org/TR/WGSL/#behaviors-rules @@ -1063,15 +970,11 @@ sem::Function* Resolver::Function(const ast::Function* decl) { } } - if (!validator_.NoDuplicateAttributes(decl->return_type_attributes)) { - return nullptr; - } + TINT_RET_IF(!validator_.NoDuplicateAttributes(decl->return_type_attributes)); auto stage = current_function_ ? current_function_->Declaration()->PipelineStage() : ast::PipelineStage::kNone; - if (!validator_.Function(func, stage)) { - return nullptr; - } + TINT_RET_IF(!validator_.Function(func, stage)); // If this is an entry point, mark all transitively called functions as being in its call graph. if (decl->IsEntryPoint()) { @@ -1092,9 +995,8 @@ bool Resolver::Statements(VectorRef stmts) { for (auto* stmt : stmts) { Mark(stmt); auto* sem = Statement(stmt); - if (!sem) { - return false; - } + TINT_RET_IF(!sem); + // s1 s2:(B1∖{Next}) ∪ B2 sem->SetIsReachable(reachable); if (reachable) { @@ -1104,10 +1006,7 @@ bool Resolver::Statements(VectorRef stmts) { } current_statement_->Behaviors() = behaviors; - - if (!validator_.Statements(stmts)) { - return false; - } + TINT_RET_IF(!validator_.Statements(stmts)); return true; } @@ -1139,12 +1038,11 @@ sem::Statement* Resolver::Statement(const ast::Statement* stmt) { // Error cases [&](const ast::CaseStatement*) { - AddError(stmt->source) << "case statement can only be used inside a switch statement"; + AddError(stmt) << "case statement can only be used inside a switch statement"; return nullptr; }, [&](Default) { - AddError(stmt->source) - << "unknown statement type: " << std::string(stmt->TypeInfo().name); + AddError(stmt) << "unknown statement type: " << std::string(stmt->TypeInfo().name); return nullptr; }); } @@ -1152,7 +1050,7 @@ sem::Statement* Resolver::Statement(const ast::Statement* stmt) { sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, const core::type::Type* ty) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { sem->Selectors().reserve(stmt->selectors.Length()); for (auto* sel : stmt->selectors) { Mark(sel); @@ -1165,16 +1063,15 @@ sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, // The sem statement was created in the switch when attempting to determine the // common type. auto* materialized = Materialize(sem_.GetVal(sel->expr), ty); - if (!materialized) { - return false; - } + TINT_RET_IF(!materialized); + if (!materialized->Type()->IsAnyOf()) { - AddError(sel->source) << "case selector must be an i32 or u32 value"; + AddError(sel) << "case selector must be an i32 or u32 value"; return false; } const_value = materialized->ConstantValue(); if (!const_value) { - AddError(sel->source) << "case selector must be a constant expression"; + AddError(sel) << "case selector must be a constant expression"; return false; } } @@ -1184,9 +1081,8 @@ sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, Mark(stmt->body); auto* body = BlockStatement(stmt->body); - if (!body) { - return false; - } + TINT_RET_IF(!body); + sem->SetBlock(body); sem->Behaviors() = body->Behaviors(); return true; @@ -1195,28 +1091,26 @@ sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, sem::IfStatement* Resolver::IfStatement(const ast::IfStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto* cond = Load(ValueExpression(stmt->condition)); - if (!cond) { - return false; - } + TINT_RET_IF(!cond); + sem->SetCondition(cond); sem->Behaviors().Remove(sem::Behavior::kNext); Mark(stmt->body); auto* body = b.create(stmt->body, current_compound_statement_, current_function_); - if (!StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })) { - return false; - } + TINT_RET_IF( + !StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })); + sem->Behaviors().Add(body->Behaviors()); if (stmt->else_statement) { Mark(stmt->else_statement); auto* else_sem = Statement(stmt->else_statement); - if (!else_sem) { - return false; - } + TINT_RET_IF(!else_sem); + sem->Behaviors().Add(else_sem->Behaviors()); } else { // https://www.w3.org/TR/WGSL/#behaviors-rules @@ -1242,10 +1136,9 @@ sem::LoopStatement* Resolver::LoopStatement(const ast::LoopStatement* stmt) { auto* body = b.create(stmt->body, current_compound_statement_, current_function_); - return StatementScope(stmt->body, body, [&] { - if (!Statements(stmt->body->statements)) { - return false; - } + return StatementScope(stmt->body, body, [&]() -> bool { + TINT_RET_IF(!Statements(stmt->body->statements)); + auto& behaviors = sem->Behaviors(); behaviors = body->Behaviors(); @@ -1261,9 +1154,8 @@ sem::LoopStatement* Resolver::LoopStatement(const ast::LoopStatement* stmt) { b.create( stmt->continuing, current_compound_statement_, current_function_), [&] { return Statements(stmt->continuing->statements); }); - if (!continuing) { - return false; - } + TINT_RET_IF(!continuing); + if (!only_return) { behaviors.Add(continuing->Behaviors()); } @@ -1285,31 +1177,28 @@ sem::LoopStatement* Resolver::LoopStatement(const ast::LoopStatement* stmt) { sem::ForLoopStatement* Resolver::ForLoopStatement(const ast::ForLoopStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto& behaviors = sem->Behaviors(); if (auto* initializer = stmt->initializer) { Mark(initializer); auto* init = Statement(initializer); - if (!init) { - return false; - } + TINT_RET_IF(!init); + behaviors.Add(init->Behaviors()); } if (auto* cond_expr = stmt->condition) { auto* cond = Load(ValueExpression(cond_expr)); - if (!cond) { - return false; - } + TINT_RET_IF(!cond); + sem->SetCondition(cond); } if (auto* continuing = stmt->continuing) { Mark(continuing); auto* cont = Statement(continuing); - if (!cont) { - return false; - } + TINT_RET_IF(!cont); + behaviors.Add(cont->Behaviors()); } @@ -1317,9 +1206,8 @@ sem::ForLoopStatement* Resolver::ForLoopStatement(const ast::ForLoopStatement* s auto* body = b.create(stmt->body, current_compound_statement_, current_function_); - if (!StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })) { - return false; - } + TINT_RET_IF( + !StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })); behaviors.Add(body->Behaviors()); if (stmt->condition || behaviors.Contains(sem::Behavior::kBreak)) { // Does the loop exit? @@ -1335,22 +1223,20 @@ sem::ForLoopStatement* Resolver::ForLoopStatement(const ast::ForLoopStatement* s sem::WhileStatement* Resolver::WhileStatement(const ast::WhileStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto& behaviors = sem->Behaviors(); auto* cond = Load(ValueExpression(stmt->condition)); - if (!cond) { - return false; - } + TINT_RET_IF(!cond); + sem->SetCondition(cond); Mark(stmt->body); auto* body = b.create(stmt->body, current_compound_statement_, current_function_); - if (!StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })) { - return false; - } + TINT_RET_IF( + !StatementScope(stmt->body, body, [&] { return Statements(stmt->body->statements); })); behaviors.Add(body->Behaviors()); if (stmt->condition || behaviors.Contains(sem::Behavior::kBreak)) { // Does the loop exit? @@ -1371,8 +1257,7 @@ sem::Expression* Resolver::Expression(const ast::Expression* root) { if (!ast::TraverseExpressions( root, [&](const ast::Expression* expr, size_t depth) { if (depth > kMaxExpressionDepth) { - AddError(expr->source) - << "reached max expression depth of " << kMaxExpressionDepth; + AddError(expr) << "reached max expression depth of " << kMaxExpressionDepth; failed = true; return ast::TraverseAction::Stop; } @@ -1388,13 +1273,11 @@ sem::Expression* Resolver::Expression(const ast::Expression* root) { sorted.Push(expr); return ast::TraverseAction::Descend; })) { - AddError(root->source) << "TraverseExpressions failed"; + AddError(root) << "TraverseExpressions failed"; return nullptr; } - if (failed) { - return nullptr; - } + TINT_RET_IF(failed); for (auto* expr : tint::Reverse(sorted)) { auto* sem_expr = Switch( @@ -1413,18 +1296,14 @@ sem::Expression* Resolver::Expression(const ast::Expression* root) { /* constant_value */ nullptr); }, // TINT_ICE_ON_NO_MATCH); - if (!sem_expr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!sem_expr)); auto* val = sem_expr->As(); if (val) { if (auto* constraint = expr_eval_stage_constraint_.constraint) { - if (!validator_.EvaluationStage(val, expr_eval_stage_constraint_.stage, - constraint)) { - return nullptr; - } + TINT_RET_IF(!validator_.EvaluationStage(val, expr_eval_stage_constraint_.stage, + constraint)); } } @@ -1454,7 +1333,7 @@ sem::Expression* Resolver::Expression(const ast::Expression* root) { return ast::TraverseAction::Descend; }); if (!r) { - AddError(root->source) << "TraverseExpressions failed"; + AddError(root) << "TraverseExpressions failed"; return nullptr; } } @@ -1487,14 +1366,10 @@ const core::type::Type* Resolver::Type(const ast::Expression* ast) { TINT_DEFER(on_transitively_reference_global_.Pop()); auto* type_expr = TypeExpression(ast); - if (DAWN_UNLIKELY(!type_expr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!type_expr)); auto* type = const_cast(type_expr->Type()); - if (DAWN_UNLIKELY(!type)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!type)); if (auto* arr = type->As()) { for (auto* ref : referenced_overrides) { @@ -1508,15 +1383,13 @@ const core::type::Type* Resolver::Type(const ast::Expression* ast) { sem::BuiltinEnumExpression* Resolver::AddressSpaceExpression( const ast::Expression* expr) { auto address_space_expr = sem_.AsAddressSpace(Expression(expr)); - if (DAWN_UNLIKELY(!address_space_expr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!address_space_expr)); + if (DAWN_UNLIKELY( address_space_expr->Value() == core::AddressSpace::kPixelLocal && !enabled_extensions_.Contains(wgsl::Extension::kChromiumExperimentalPixelLocal))) { - AddError(expr->source) << "'pixel_local' address space requires the '" - << wgsl::Extension::kChromiumExperimentalPixelLocal - << "' extension enabled"; + AddError(expr) << "'pixel_local' address space requires the '" + << wgsl::Extension::kChromiumExperimentalPixelLocal << "' extension enabled"; return nullptr; } return address_space_expr; @@ -1548,6 +1421,143 @@ void Resolver::RegisterLoad(const sem::ValueExpression* expr) { }); } +void Resolver::RegisterBufferView(const sem::Call* call, wgsl::BuiltinFn fn) { + uint64_t buffer_size = 0; + auto* ret_type = call->Target()->ReturnType(); + auto* ret_ptr_type = ret_type->As(); + auto* ret_store_type = ret_ptr_type->StoreType(); + if (ret_store_type->HasFixedFootprint()) { + buffer_size = ret_store_type->Size(); + } else { + if (const auto* str_ty = ret_store_type->As()) { + const auto* last = str_ty->Members().Back(); + const auto* last_type = last->Type(); + TINT_ASSERT(last_type->Is()); + buffer_size = last->Offset() + last_type->As()->ImplicitStride(); + } else if (const auto* arr_ty = ret_store_type->As()) { + buffer_size = arr_ty->ImplicitStride(); + } else { + // Any other type should be caught be validation as an error. + TINT_UNREACHABLE() << "unexpected return type for " + << call->Target()->As()->str(); + } + } + + auto* offset = call->Arguments()[1]; + auto* offset_constant_value = offset->ConstantValue(); + uint64_t offset_value = 0; + if (offset_constant_value) { + if (offset->Type()->IsUnsignedIntegerScalar()) { + offset_value = offset_constant_value->ValueAs(); + } else { + TINT_ASSERT(offset->Type()->IsSignedIntegerScalar()); + int32_t ivalue = offset_constant_value->ValueAs(); + offset_value = static_cast(ivalue); + } + } + if (fn == wgsl::BuiltinFn::kBufferView) { + buffer_size += offset_value; + } else { + TINT_ASSERT(fn == wgsl::BuiltinFn::kBufferArrayView); + uint64_t size_value = 0; + auto* size = call->Arguments()[2]; + auto* size_constant_value = size->ConstantValue(); + if (size_constant_value) { + size_value = std::numeric_limits::max(); + if (size->Type()->IsUnsignedIntegerScalar()) { + size_value = size_constant_value->ValueAs(); + } else { + TINT_ASSERT(size->Type()->IsSignedIntegerScalar()); + int32_t ivalue = size_constant_value->ValueAs(); + size_value = static_cast(ivalue); + } + } + buffer_size = offset_value + std::max(size_value, buffer_size); + } + + if (const auto* param = call->RootIdentifier()->As()) { + auto where = buffer_view_sizes_.GetOrAddEntry(param, [buffer_size, call]() { + BufferViewInfo info; + info.size = buffer_size; + info.node = call->Declaration(); + return info; + }); + where.value = {std::max(buffer_size, where.value.size), where.value.node}; + } + // Only need to add a transitive size reference for global variables. + if (const auto* gvar = call->RootIdentifier()->As()) { + auto* var_ty = gvar->Type()->UnwrapPtrOrRef(); + auto* buf_ty = var_ty->As(); + if (buf_ty && buf_ty->Count()->Is() && current_function_) { + current_function_->AddTransitivelyReferencedUnsizedBufferSize(gvar, buffer_size); + } + } +} + +bool Resolver::CheckBufferViews(const sem::Call* call) { + auto* target = call->Target()->As(); + if (!target) { + return true; + } + + auto& args = call->Arguments(); + for (size_t i = 0; i < args.Length(); i++) { + auto* arg = args[i]; + if (!arg->Type()->Is()) { + continue; + } + + auto* root = arg->RootIdentifier(); + auto where = buffer_view_sizes_.Get(target->Parameters()[i]); + if (where) { + bool ret = Switch( + root, + [&](const sem::GlobalVariable* global) { + const auto* ty = global->Type()->UnwrapPtrOrRef(); + if (const auto* buffer_ty = ty->As()) { + auto count = buffer_ty->ConstantCount(); + if (count != std::nullopt && count.value() < where->size) { + AddError(global->Declaration()) + << "buffer size (" << count.value() + << " bytes) is smaller than the minimum view size (" << where->size + << " bytes)"; + AddNote(where->node) << "due to call here"; + return false; + } + // Add transitive reference to global. + if (buffer_ty->Count()->Is()) { + current_function_->AddTransitivelyReferencedUnsizedBufferSize( + global, where->size); + } + } + return true; + }, + [&](const sem::Parameter* param) { + const auto* ty = param->Type()->UnwrapPtrOrRef(); + if (const auto* buffer_ty = ty->As()) { + auto count = buffer_ty->ConstantCount(); + if (count != std::nullopt && count.value() < where->size) { + AddError(param->Declaration()) + << "buffer size (" << count.value() + << " bytes) is smaller than the minimum view size (" << where->size + << " bytes)"; + AddNote(where->node) << "due to call here"; + return false; + } + } + auto param_where = + buffer_view_sizes_.GetOrAddEntry(param, [where]() { return *where; }); + param_where.value = {std::max(param_where.value.size, where->size), + where->node}; + return true; + }); + TINT_RET_IF(!ret); + } + } + + return true; +} + bool Resolver::AliasAnalysis(const sem::Call* call) { auto* target = call->Target()->As(); if (!target) { @@ -1561,18 +1571,16 @@ bool Resolver::AliasAnalysis(const sem::Call* call) { std::string access; // the access performed for the "other" expression }; auto make_error = [&](const sem::ValueExpression* arg, Alias&& var) { - AddError(arg->Declaration()->source) << "invalid aliased pointer argument"; + AddError(arg->Declaration()) << "invalid aliased pointer argument"; switch (var.type) { case Alias::Argument: - AddNote(var.expr->Declaration()->source) - << "aliases with another argument passed here"; + AddNote(var.expr->Declaration()) << "aliases with another argument passed here"; break; case Alias::ModuleScope: { auto* func = var.expr->Stmt()->Function(); auto func_name = func->Declaration()->name->symbol.NameView(); - AddNote(var.expr->Declaration()->source) - << "aliases with module-scope variable " << var.access << " in '" << func_name - << "'"; + AddNote(var.expr->Declaration()) << "aliases with module-scope variable " + << var.access << " in '" << func_name << "'"; break; } } @@ -1700,10 +1708,8 @@ const core::type::Type* Resolver::ConcreteType(const core::type::Type* ty, } const sem::ValueExpression* Resolver::Load(const sem::ValueExpression* expr) { - if (!expr) { - // Allow for Load(ValueExpression(blah)), where failures pass through Load() - return nullptr; - } + // Allow for Load(ValueExpression(blah)), where failures pass through Load() + TINT_RET_IF(DAWN_UNLIKELY(!expr)); // When requested, wrap a swizzle view in an ephemeral Load in order to correctly resolve types // for validation. Because this sem::Load will not become a true load during lowering to IR, @@ -1733,10 +1739,8 @@ const sem::ValueExpression* Resolver::Load(const sem::ValueExpression* expr) { const sem::ValueExpression* Resolver::Materialize( const sem::ValueExpression* expr, const core::type::Type* target_type /* = nullptr */) { - if (!expr) { - // Allow for Materialize(ValueExpression(blah)), where failures pass through Materialize() - return nullptr; - } + // Allow for Materialize(ValueExpression(blah)), where failures pass through Materialize() + TINT_RET_IF(DAWN_UNLIKELY(!expr)); auto* decl = expr->Declaration(); @@ -1746,9 +1750,7 @@ const sem::ValueExpression* Resolver::Materialize( } auto* src_ty = expr->Type(); - if (!validator_.Materialize(concrete_ty, src_ty, decl->source)) { - return nullptr; - } + TINT_RET_IF(!validator_.Materialize(concrete_ty, src_ty, decl->source)); const core::constant::Value* materialized_val = nullptr; if (!not_evaluated_.Contains(decl)) { @@ -1759,10 +1761,9 @@ const sem::ValueExpression* Resolver::Materialize( } auto val = const_eval_.Convert(concrete_ty, expr_val, decl->source); - if (val != Success) { - // Convert() has already failed and raised an diagnostic error. - return nullptr; - } + // Convert() has already failed and raised an diagnostic error. + TINT_RET_IF(val != Success); + materialized_val = val.Get(); if (DAWN_UNLIKELY(!materialized_val)) { ICE(decl->source) << "ConvertValue(" << expr_val->Type()->FriendlyName() << " -> " @@ -1781,9 +1782,8 @@ bool Resolver::MaybeMaterializeArguments(Vector& for (size_t i = 0, n = std::min(args.Length(), target->Parameters().Length()); i < n; i++) { const auto* param_ty = target->Parameters()[i]->Type(); auto* materialized = Materialize(args[i], param_ty); - if (!materialized) { - return false; - } + TINT_RET_IF(!materialized); + args[i] = materialized; } return true; @@ -1793,9 +1793,8 @@ bool Resolver::Convert(const core::constant::Value*& c, const core::type::Type* target_ty, const Source& source) { auto r = const_eval_.Convert(target_ty, c, source); - if (r != Success) { - return false; - } + TINT_RET_IF(r != Success); + c = r.Get(); return true; } @@ -1833,9 +1832,8 @@ const core::constant::Value* Resolver::ConvertConstArgument( sem::ValueExpression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* expr) { auto* idx = Load(Materialize(sem_.GetVal(expr->index))); - if (!idx) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!idx)); + const auto* obj = sem_.GetVal(expr->object); if (idx->Stage() != core::EvaluationStage::kConstant) { // If the index is non-constant, then the resulting expression is non-constant, so we'll @@ -1843,20 +1841,12 @@ sem::ValueExpression* Resolver::IndexAccessor(const ast::IndexAccessorExpression // vec2(1, 2)[runtime-index] obj = Materialize(obj); } - if (!obj) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!obj)); + auto* object_ty = obj->Type(); auto* const memory_view = object_ty->As(); - const core::type::Type* storage_ty = object_ty->UnwrapRef(); + const core::type::Type* storage_ty = object_ty; if (memory_view) { - if (memory_view->Is() && - !allowed_features_.features.contains(wgsl::LanguageFeature::kPointerCompositeAccess)) { - AddError(expr->source) - << "pointer composite access requires the pointer_composite_access language " - "feature, which is not allowed in the current environment"; - return nullptr; - } storage_ty = memory_view->StoreType(); } @@ -1869,16 +1859,14 @@ sem::ValueExpression* Resolver::IndexAccessor(const ast::IndexAccessorExpression return b.create(mat->Type(), mat->Rows()); }, [&](Default) { - AddError(expr->source) << "cannot index type '" << sem_.TypeNameOf(storage_ty) << "'"; + AddError(expr) << "cannot index type '" << sem_.TypeNameOf(storage_ty) << "'"; return nullptr; }); - if (ty == nullptr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); auto* idx_ty = idx->Type()->UnwrapRef(); if (!idx_ty->IsAnyOf()) { - AddError(idx->Declaration()->source) + AddError(idx->Declaration()) << "index must be of type 'i32' or 'u32', found: '" << sem_.TypeNameOf(idx_ty) << "'"; return nullptr; } @@ -1897,9 +1885,7 @@ sem::ValueExpression* Resolver::IndexAccessor(const ast::IndexAccessorExpression if (auto* idx_val = idx->ConstantValue()) { auto res = const_eval_.Index(obj->ConstantValue(), storage_ty, idx_val, idx->Declaration()->source); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); val = res.Get(); } } @@ -1915,9 +1901,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { // * A value constructor. // * A value conversion. auto* target = sem_.Get(expr->target); - if (DAWN_UNLIKELY(!target)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!target)); // Resolve all of the arguments, their types and the set of behaviors. Vector args; @@ -1925,22 +1909,22 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { auto args_stage = core::EvaluationStage::kConstant; for (size_t i = 0; i < expr->args.Length(); i++) { const auto* arg = Load(sem_.GetVal(expr->args[i])); - if (!arg) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!arg)); + args.Push(arg); args_stage = core::EarliestStage(args_stage, arg->Stage()); } // ctor_or_conv is a helper for building either a sem::ValueConstructor or // sem::ValueConversion call for a CtorConvIntrinsic with an optional template argument type. - auto ctor_or_conv = [&](CtorConvIntrinsic ty, - VectorRef template_args) -> sem::Call* { + auto ctor_or_conv = + [&](CtorConvIntrinsic ty, + VectorRef template_args) -> sem::Call* { auto arg_tys = tint::Transform(args, [&](auto* arg) { return arg->Type(); }); auto match = intrinsic_table_.Lookup(ty, template_args, arg_tys, args_stage); if (match != Success) { - AddError(expr->source) << match.Failure(); + AddError(expr) << match.Failure(); return nullptr; } @@ -1969,9 +1953,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { }); } - if (!MaybeMaterializeArguments(args, target_sem)) { - return nullptr; - } + TINT_RET_IF(!MaybeMaterializeArguments(args, target_sem)); const core::constant::Value* value = nullptr; auto stage = core::EarliestStage(overload_stage, args_stage); @@ -1980,15 +1962,12 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { } if (stage == core::EvaluationStage::kConstant) { auto const_args = ConvertArguments(args, target_sem); - if (const_args != Success) { - return nullptr; - } + TINT_RET_IF(const_args != Success); + auto const_eval_fn = match->const_eval_fn; auto r = (const_eval_.*const_eval_fn)(target_sem->ReturnType(), const_args.Get(), expr->source); - if (r != Success) { - return nullptr; - } + TINT_RET_IF(r != Success); value = r.Get(); } return b.create(expr, target_sem, stage, std::move(args), current_statement_, @@ -2010,13 +1989,11 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { } if (stage == core::EvaluationStage::kConstant) { auto const_args = ConvertArguments(args, call_target); - if (const_args != Success) { - return nullptr; - } + TINT_RET_IF(const_args != Success); + auto r = const_eval_.ArrayOrStructCtor(ty, std::move(const_args.Get())); - if (r != Success) { - return nullptr; - } + TINT_RET_IF(r != Success); + value = r.Get(); if (!value) { // Constant evaluation failed. @@ -2045,11 +2022,12 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { [&](const core::type::F32*) { return ctor_or_conv(CtorConvIntrinsic::kF32, Empty); }, [&](const core::type::Bool*) { return ctor_or_conv(CtorConvIntrinsic::kBool, Empty); }, [&](const core::type::Vector* v) { - return ctor_or_conv(wgsl::intrinsic::VectorCtorConv(v->Width()), Vector{v->Type()}); + return ctor_or_conv(wgsl::intrinsic::VectorCtorConv(v->Width()), + Vector{v->Type()}); }, [&](const core::type::Matrix* m) { return ctor_or_conv(wgsl::intrinsic::MatrixCtorConv(m->Columns(), m->Rows()), - Vector{m->Type()}); + Vector{m->Type()}); }, [&](const sem::Array* arr) -> sem::Call* { auto* call_target = array_ctors_.GetOrAdd( @@ -2063,13 +2041,8 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { return b.create(arr, std::move(params), args_stage); }); - if (DAWN_UNLIKELY(!MaybeMaterializeArguments(args, call_target))) { - return nullptr; - } - - if (DAWN_UNLIKELY(!validator_.ArrayConstructor(expr, arr))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!MaybeMaterializeArguments(args, call_target))); + TINT_RET_IF(DAWN_UNLIKELY(!validator_.ArrayConstructor(expr, arr))); return arr_or_str_init(arr, call_target); }, @@ -2088,13 +2061,8 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { return b.create(str, std::move(params), args_stage); }); - if (DAWN_UNLIKELY(!MaybeMaterializeArguments(args, call_target))) { - return nullptr; - } - - if (DAWN_UNLIKELY(!validator_.StructureInitializer(expr, str))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!MaybeMaterializeArguments(args, call_target))); + TINT_RET_IF(DAWN_UNLIKELY(!validator_.StructureInitializer(expr, str))); return arr_or_str_init(str, call_target); }, @@ -2118,13 +2086,9 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { core::EvaluationStage::kRuntime); }); - if (DAWN_UNLIKELY(!MaybeMaterializeArguments(args, call_target))) { - return nullptr; - } - - if (DAWN_UNLIKELY(!validator_.SubgroupMatrixConstructor(expr, m, call_target))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!MaybeMaterializeArguments(args, call_target))); + TINT_RET_IF( + DAWN_UNLIKELY(!validator_.SubgroupMatrixConstructor(expr, m, call_target))); // Subgroup matrix constructors are never const-evaluated. auto stage = core::EvaluationStage::kRuntime; @@ -2136,7 +2100,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { current_statement_, nullptr); }, [&](Default) { - AddError(expr->source) << "type is not constructible"; + AddError(expr) << "type is not constructible"; return nullptr; }); }; @@ -2175,12 +2139,12 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { auto arg_tys = tint::Transform(args, [](auto* arg) { return arg->Type(); }); auto el_ty = core::type::Type::Common(arg_tys); if (DAWN_UNLIKELY(!el_ty)) { - AddError(expr->source) + AddError(expr) << "cannot infer common array element type from constructor arguments"; Hashset types; for (size_t i = 0; i < args.Length(); i++) { if (types.Add(args[i]->Type())) { - AddNote(args[i]->Declaration()->source) + AddNote(args[i]->Declaration()) << "argument " << i << " is of type '" << sem_.TypeNameOf(args[i]->Type()) << "'"; } @@ -2188,9 +2152,8 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { return nullptr; } auto* arr = Array(expr->source, expr->source, expr->source, el_ty, el_count); - if (DAWN_UNLIKELY(!arr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!arr)); + return ty_init_or_conv(arr); } default: { @@ -2210,9 +2173,8 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { ty_expr->Type(), // [&](const IncompleteType* t) -> sem::Call* { auto* ctor = incomplete_type(t); - if (DAWN_UNLIKELY(!ctor)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ctor)); + // Replace incomplete type with resolved type const_cast(ty_expr)->SetType(ctor->Type()); return ctor; @@ -2227,9 +2189,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) { return nullptr; }); - if (!call) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!call)); return validator_.Call(call, current_statement_) ? call : nullptr; } @@ -2243,14 +2203,21 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, arg_stage = core::EarliestStage(arg_stage, arg->Stage()); } - Vector tmpl_args; + Vector tmpl_args; if (auto* tmpl = expr->target->identifier->As()) { for (auto* arg : tmpl->arguments) { - auto* arg_ty = sem_.AsTypeExpression(sem_.Get(arg)); - if (DAWN_UNLIKELY(!arg_ty)) { - return nullptr; + auto* sem_expr = sem_.Get(arg); + if (auto* arg_ty = sem_expr->As(); DAWN_LIKELY(arg_ty)) { + tmpl_args.Push(arg_ty->Type()); + } else if (auto* arg_major = + sem_expr->As>()) { + tmpl_args.Push(arg_major->Value()); + } else { + // Add an error, but don't return so that the candidates are printed. + // Use a bad type. + AddError(arg) << "Unexpected template kind"; + tmpl_args.Push(b.create()); } - tmpl_args.Push(arg_ty->Type()); } } @@ -2258,7 +2225,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, auto overload = intrinsic_table_.Lookup(fn, tmpl_args, arg_tys, arg_stage); if (overload != Success) { - AddError(expr->source) << overload.Failure(); + AddError(expr) << overload.Failure(); return nullptr; } @@ -2285,19 +2252,17 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, }); // Materialize arguments if the parameter type is not abstract - if (!MaybeMaterializeArguments(args, target)) { - return nullptr; - } + TINT_RET_IF(!MaybeMaterializeArguments(args, target)); if (target->IsDeprecated()) { - AddWarning(expr->source) << "use of deprecated builtin"; + AddWarning(expr) << "use of deprecated builtin"; } // Check evaluation stage of parameters that are required to be const-expressions. for (uint32_t i = 0; i < overload->parameters.Length(); i++) { const auto& p = overload->parameters[i]; if (p.is_const && args[i]->Stage() != core::EvaluationStage::kConstant) { - AddError(args[i]->Declaration()->source) + AddError(args[i]->Declaration()) << "the " << style::Variable(p.usage) << " argument of " << style::Function(target->str()) << " must be a const-expression"; return nullptr; @@ -2313,20 +2278,19 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, } if (stage == core::EvaluationStage::kConstant) { auto const_args = ConvertArguments(args, target); - if (const_args != Success) { - return nullptr; - } + TINT_RET_IF(const_args != Success); + auto const_eval_fn = overload->const_eval_fn; auto r = (const_eval_.*const_eval_fn)(target->ReturnType(), const_args.Get(), expr->source); - if (r != Success) { - return nullptr; - } + TINT_RET_IF(r != Success); + value = r.Get(); } - // If the builtin is bufferView, set the root identifier based on the first argument. + // If the builtin is bufferView or bufferArrayView, set the root identifier based on the first + // argument. const sem::Variable* root_ident = nullptr; - if (fn == wgsl::BuiltinFn::kBufferView) { + if (fn == wgsl::BuiltinFn::kBufferView || fn == wgsl::BuiltinFn::kBufferArrayView) { root_ident = args[0]->RootIdentifier(); } auto* call = b.create(expr, target, stage, std::move(args), current_statement_, @@ -2337,15 +2301,8 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, current_function_->AddDirectCall(call); } - if (!validator_.RequiredFeaturesForBuiltinFn(call)) { - return nullptr; - } - - if (IsTexture(fn)) { - if (!validator_.TextureBuiltinFn(call)) { - return nullptr; - } - } + TINT_RET_IF(!validator_.RequiredFeaturesForBuiltinFn(call)); + TINT_RET_IF(IsTexture(fn) && !validator_.TextureBuiltinFn(call)); switch (fn) { case wgsl::BuiltinFn::kWorkgroupUniformLoad: @@ -2353,23 +2310,17 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, break; case wgsl::BuiltinFn::kSubgroupBroadcast: - if (!validator_.SubgroupBroadcast(call)) { - return nullptr; - } + TINT_RET_IF(!validator_.SubgroupBroadcast(call)); break; case wgsl::BuiltinFn::kSubgroupShuffle: case wgsl::BuiltinFn::kSubgroupShuffleUp: case wgsl::BuiltinFn::kSubgroupShuffleDown: case wgsl::BuiltinFn::kSubgroupShuffleXor: - if (!validator_.SubgroupShuffleFunction(fn, call)) { - return nullptr; - } + TINT_RET_IF(!validator_.SubgroupShuffleFunction(fn, call)); break; case wgsl::BuiltinFn::kQuadBroadcast: - if (!validator_.QuadBroadcast(call)) { - return nullptr; - } + TINT_RET_IF(!validator_.QuadBroadcast(call)); break; case wgsl::BuiltinFn::kAtomicLoad: @@ -2402,17 +2353,17 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, RegisterStore(args[0]); break; - case wgsl::BuiltinFn::kBufferView: { + case wgsl::BuiltinFn::kBufferView: + case wgsl::BuiltinFn::kBufferArrayView: { + TINT_RET_IF(!validator_.BufferView(call)); + RegisterBufferView(call, fn); auto address_space = call->Target()->ReturnType()->template As()->AddressSpace(); auto* store_type = call->Target()->ReturnType()->template As()->StoreType(); if (!ApplyAddressSpaceUsageToType(address_space, store_type, call->Declaration()->source)) { - AddNote(call->Declaration()->source) << " while instantiating bufferView"; - return nullptr; - } - if (!validator_.BufferView(call)) { + AddNote(call->Declaration()) << " while instantiating bufferView"; return nullptr; } break; @@ -2432,9 +2383,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, // first argument. auto fakeArgs = Vector{lowConst, lowConst, highConst}; auto res = const_eval_.clamp(call->Type(), fakeArgs, call->Declaration()->source); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); } } break; case wgsl::BuiltinFn::kLdexp: @@ -2442,9 +2391,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, auto* zero = const_eval_.Zero(call->Type(), {}, Source{}).Get(); auto fakeArgs = Vector{zero, exponentConst}; auto res = const_eval_.ldexp(call->Type(), fakeArgs, call->Declaration()->source); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); } break; case wgsl::BuiltinFn::kExtractBits: { @@ -2455,9 +2402,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, auto fakeArgs = Vector{zero, offsetConst, countConst}; auto res = const_eval_.extractBits(call->Type(), fakeArgs, call->Declaration()->source); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); } } break; case wgsl::BuiltinFn::kInsertBits: { @@ -2468,9 +2413,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, auto fakeArgs = Vector{zero, zero, offsetConst, countConst}; auto res = const_eval_.insertBits(call->Type(), fakeArgs, call->Declaration()->source); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); } } break; case wgsl::BuiltinFn::kSmoothstep: { @@ -2482,18 +2425,14 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr, auto fakeArgs = Vector{lowConst, highConst, highConst}; auto res = const_eval_.smoothstep(call->Type(), fakeArgs, call->Declaration()->source); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); } } break; default: break; } - if (!validator_.BuiltinCall(call)) { - return nullptr; - } + TINT_RET_IF(!validator_.BuiltinCall(call)); return call; } @@ -2757,19 +2696,15 @@ const core::type::U8* Resolver::U8(const ast::Identifier* ident) { } const core::type::U16* Resolver::U16(const ast::Identifier* ident) { - AddError(ident->source) << "u16 is unsupported in WGSL"; + AddError(ident) << "u16 is unsupported in WGSL"; return nullptr; } const core::type::Vector* Resolver::Vec(const ast::Identifier* ident, const core::type::Type* el, uint32_t n) { - if (DAWN_UNLIKELY(!el)) { - return nullptr; - } - if (DAWN_UNLIKELY(!validator_.Vector(el, ident->source))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el)); + TINT_RET_IF(DAWN_UNLIKELY(!validator_.Vector(el, ident->source))); return b.create(el, n); } @@ -2781,15 +2716,10 @@ const core::type::Type* Resolver::VecT(const ast::Identifier* ident, // 'vecN' has no template arguments, so return an incomplete type. return b.create(builtin); } - - if (DAWN_UNLIKELY(!CheckTemplatedIdentifierArgs(tmpl_ident, 1))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!CheckTemplatedIdentifierArgs(tmpl_ident, 1))); auto* ty = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); return Vec(ident, const_cast(ty), n); } @@ -2798,16 +2728,12 @@ const core::type::Matrix* Resolver::Mat(const ast::Identifier* ident, const core::type::Type* el, uint32_t num_columns, uint32_t num_rows) { - if (DAWN_UNLIKELY(!el)) { - return nullptr; - } - if (DAWN_UNLIKELY(!validator_.Matrix(el, ident->source))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el)); + TINT_RET_IF(DAWN_UNLIKELY(!validator_.Matrix(el, ident->source))); + auto* column = Vec(ident, el, num_rows); - if (!column) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!column)); + return b.create(column, num_columns); } @@ -2820,15 +2746,10 @@ const core::type::Type* Resolver::MatT(const ast::Identifier* ident, // 'vecN' has no template arguments, so return an incomplete type. return b.create(builtin); } - - if (DAWN_UNLIKELY(!CheckTemplatedIdentifierArgs(tmpl_ident, 1))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!CheckTemplatedIdentifierArgs(tmpl_ident, 1))); auto* el_ty = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!el_ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el_ty)); return Mat(ident, const_cast(el_ty), num_columns, num_rows); } @@ -2840,30 +2761,23 @@ const core::type::Type* Resolver::Array(const ast::Identifier* ident) { return b.create(core::BuiltinType::kArray); } - if (DAWN_UNLIKELY(!CheckTemplatedIdentifierArgs(tmpl_ident, 1, 2))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!CheckTemplatedIdentifierArgs(tmpl_ident, 1, 2))); + auto* ast_el_ty = tmpl_ident->arguments[0]; auto* ast_count = (tmpl_ident->arguments.Length() > 1) ? tmpl_ident->arguments[1] : nullptr; auto* el_ty = sem_.GetType(ast_el_ty); - if (!el_ty) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el_ty)); const core::type::ArrayCount* el_count = ast_count ? ArrayCount(ast_count) : b.create(); - if (!el_count) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el_count)); auto* out = Array(tmpl_ident->source, // ast_el_ty->source, // ast_count ? ast_count->source : ident->source, // el_ty, el_count); - if (!out) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!out)); if (el_ty->Is()) { atomic_composite_info_.Add(out, &ast_el_ty->source); @@ -2881,138 +2795,76 @@ const core::type::Type* Resolver::Array(const ast::Identifier* ident) { const core::type::BindingArray* Resolver::BindingArray(const ast::Identifier* ident) { auto* tmpl_ident = TemplatedIdentifier(ident, 2); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto* el_type = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!el_type)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el_type)); const core::type::ArrayCount* el_count = ArrayCount(tmpl_ident->arguments[1]); - if (!el_count) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el_count)); auto* out = b.create(el_type, el_count); - if (DAWN_UNLIKELY(!validator_.BindingArray(out, ident->source))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!validator_.BindingArray(out, ident->source))); return out; } const core::type::Atomic* Resolver::Atomic(const ast::Identifier* ident) { auto* tmpl_ident = TemplatedIdentifier(ident, 1); // atomic - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto* el_ty = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!el_ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!el_ty)); auto* out = b.create(el_ty); - if (DAWN_UNLIKELY(!validator_.Atomic(tmpl_ident, out))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!validator_.Atomic(tmpl_ident, out))); + return out; } const core::type::Pointer* Resolver::Ptr(const ast::Identifier* ident) { auto* tmpl_ident = TemplatedIdentifier(ident, 2, 3); // ptr - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto address_space = sem_.GetAddressSpace(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(address_space == core::AddressSpace::kUndefined)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(address_space == core::AddressSpace::kUndefined)); auto* store_ty = const_cast(sem_.GetType(tmpl_ident->arguments[1])); - if (DAWN_UNLIKELY(!store_ty)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!store_ty)); core::Access access = core::Access::kUndefined; if (tmpl_ident->arguments.Length() > 2) { access = sem_.GetAccess(tmpl_ident->arguments[2]); - if (DAWN_UNLIKELY(access == core::Access::kUndefined)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(access == core::Access::kUndefined)); } else { access = DefaultAccessForAddressSpace(address_space); } auto* out = b.create(address_space, store_ty, access); - if (DAWN_UNLIKELY(!validator_.Pointer(tmpl_ident, out))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!validator_.Pointer(tmpl_ident, out))); if (!ApplyAddressSpaceUsageToType(address_space, store_ty, tmpl_ident->arguments[1]->source)) { - AddNote(ident->source) << "while instantiating " << out->FriendlyName(); + AddNote(ident) << "while instantiating " << out->FriendlyName(); return nullptr; } return out; } const core::type::Sampler* Resolver::Sampler(const ast::Identifier* ident) { - if (!allowed_features_.features.contains(wgsl::LanguageFeature::kFilteringParameters)) { - return DAWN_LIKELY(CheckNotTemplated("type", ident)) - ? b.create(core::type::SamplerKind::kSampler) - : nullptr; - } - - core::SamplerFiltering filtering = core::SamplerFiltering::kUndefined; - if (auto* tmpl_ident = ident->As()) { - // If we are templated, then there must be at least one template item - if (!CheckTemplatedIdentifierArgs(tmpl_ident, 1)) { - return nullptr; - } - - if (auto resolved = dependencies_.resolved_identifiers.Get(ident)) { - if (auto* ast_node = resolved->Node()) { - sem_.NoteDeclarationSource(ast_node); - } - } - - filtering = sem_.GetSamplerFiltering(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(filtering == core::SamplerFiltering::kUndefined)) { - return nullptr; - } - } - return b.create(core::type::SamplerKind::kSampler, filtering); + return DAWN_LIKELY(CheckNotTemplated("type", ident)) + ? b.create(core::type::SamplerKind::kSampler) + : nullptr; } const core::type::SampledTexture* Resolver::SampledTexture(const ast::Identifier* ident, core::type::TextureDimension dim) { - uint32_t allowed_args = 1; - if (allowed_features_.features.contains(wgsl::LanguageFeature::kFilteringParameters)) { - allowed_args = 2; - } - - auto* tmpl_ident = TemplatedIdentifier(ident, 1, allowed_args); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + auto* tmpl_ident = TemplatedIdentifier(ident, 1); + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto* ty_expr = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!ty_expr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty_expr)); - core::TextureFilterable filterable = core::TextureFilterable::kUndefined; - if (tmpl_ident->arguments.Length() > 1) { - filterable = sem_.GetTextureFilterable(tmpl_ident->arguments[1]); - if (DAWN_UNLIKELY(filterable == core::TextureFilterable::kUndefined)) { - return nullptr; - } - } - - auto* out = b.create(dim, ty_expr, filterable); + auto* out = b.create(dim, ty_expr); return validator_.SampledTexture(out, ident->source) ? out : nullptr; } @@ -3020,14 +2872,10 @@ const core::type::MultisampledTexture* Resolver::MultisampledTexture( const ast::Identifier* ident, core::type::TextureDimension dim) { auto* tmpl_ident = TemplatedIdentifier(ident, 1); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto* ty_expr = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!ty_expr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty_expr)); auto* out = b.create(dim, ty_expr); return validator_.MultisampledTexture(out, ident->source) ? out : nullptr; @@ -3036,38 +2884,26 @@ const core::type::MultisampledTexture* Resolver::MultisampledTexture( const core::type::StorageTexture* Resolver::StorageTexture(const ast::Identifier* ident, core::type::TextureDimension dim) { auto* tmpl_ident = TemplatedIdentifier(ident, 2); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto format = sem_.GetTexelFormat(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(format == core::TexelFormat::kUndefined)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(format == core::TexelFormat::kUndefined)); auto access = sem_.GetAccess(tmpl_ident->arguments[1]); - if (DAWN_UNLIKELY(access == core::Access::kUndefined)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(access == core::Access::kUndefined)); auto* tex = b.Types().storage_texture(dim, format, access); - if (!validator_.StorageTexture(tex, ident->source)) { - return nullptr; - } + TINT_RET_IF(!validator_.StorageTexture(tex, ident->source)); return tex; } const core::type::InputAttachment* Resolver::InputAttachment(const ast::Identifier* ident) { auto* tmpl_ident = TemplatedIdentifier(ident, 1); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto* ty_expr = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!ty_expr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty_expr)); auto* out = b.create(ty_expr); return validator_.InputAttachment(out, ident->source) ? out : nullptr; @@ -3076,36 +2912,28 @@ const core::type::InputAttachment* Resolver::InputAttachment(const ast::Identifi const core::type::SubgroupMatrix* Resolver::SubgroupMatrix(const ast::Identifier* ident, core::SubgroupMatrixKind kind) { auto* tmpl_ident = TemplatedIdentifier(ident, 3); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto* ty_expr = sem_.GetType(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(!ty_expr)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty_expr)); auto get_dim = [&](const ast::Expression* arg, const char* dim) -> const core::constant::Value* { const auto* cols_sem = Materialize(sem_.GetVal(arg)); - if (!cols_sem) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!cols_sem)); + if (!cols_sem->ConstantValue() || cols_sem->ConstantValue()->ValueAs() < 1) { - AddError(arg->source) << "subgroup matrix " << dim - << " count must be a constant positive integer"; + AddError(arg) << "subgroup matrix " << dim + << " count must be a constant positive integer"; return nullptr; } return cols_sem->ConstantValue(); }; auto* cols = get_dim(tmpl_ident->arguments[1], "column"); - if (!cols) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!cols)); + auto* rows = get_dim(tmpl_ident->arguments[2], "row"); - if (!rows) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!rows)); auto* out = b.create(kind, ty_expr, cols->ValueAs(), rows->ValueAs()); @@ -3122,14 +2950,12 @@ const core::type::Buffer* Resolver::Buffer(const ast::Identifier* ident) { core::type::Buffer* out = nullptr; if (ident->Is()) { auto* tmpl_ident = TemplatedIdentifier(ident, 1); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); + auto* arg = tmpl_ident->arguments[0]; const core::type::ArrayCount* size = ArrayCount(arg, /* array = */ false); - if (!size) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!size)); + out = b.create(size); } else { out = b.create(b.create()); @@ -3139,25 +2965,16 @@ const core::type::Buffer* Resolver::Buffer(const ast::Identifier* ident) { const core::type::TexelBuffer* Resolver::TexelBuffer(const ast::Identifier* ident) { auto* tmpl_ident = TemplatedIdentifier(ident, 2); - if (DAWN_UNLIKELY(!tmpl_ident)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!tmpl_ident)); auto format = sem_.GetTexelFormat(tmpl_ident->arguments[0]); - if (DAWN_UNLIKELY(format == core::TexelFormat::kUndefined)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(format == core::TexelFormat::kUndefined)); auto access = sem_.GetAccess(tmpl_ident->arguments[1]); - if (DAWN_UNLIKELY(access == core::Access::kUndefined)) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(access == core::Access::kUndefined)); auto* out = b.Types().texel_buffer(format, access); - - if (DAWN_UNLIKELY(!validator_.TexelBuffer(out, ident->source))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!validator_.TexelBuffer(out, ident->source))); return out; } @@ -3184,19 +3001,19 @@ bool Resolver::CheckTemplatedIdentifierArgs(const ast::TemplatedIdentifier* iden } if (min_args == max_args) { if (DAWN_UNLIKELY(ident->arguments.Length() != min_args)) { - AddError(ident->source) << style::Code(ident->symbol.NameView()) << " requires " - << min_args << " template arguments"; + AddError(ident) << style::Code(ident->symbol.NameView()) << " requires " << min_args + << " template arguments"; return false; } } else { if (DAWN_UNLIKELY(ident->arguments.Length() < min_args)) { - AddError(ident->source) << style::Code(ident->symbol.NameView()) - << " requires at least " << min_args << " template arguments"; + AddError(ident) << style::Code(ident->symbol.NameView()) << " requires at least " + << min_args << " template arguments"; return false; } if (DAWN_UNLIKELY(ident->arguments.Length() > max_args)) { - AddError(ident->source) << style::Code(ident->symbol.NameView()) << " requires at most " - << max_args << " template arguments"; + AddError(ident) << style::Code(ident->symbol.NameView()) << " requires at most " + << max_args << " template arguments"; return false; } } @@ -3220,9 +3037,7 @@ sem::Call* Resolver::FunctionCall(const ast::CallExpression* expr, sem::Function* target, VectorRef args_in) { Vector args = std::move(args_in); - if (!MaybeMaterializeArguments(args, target)) { - return nullptr; - } + TINT_RET_IF(!MaybeMaterializeArguments(args, target)); auto stage = not_evaluated_.Contains(expr) ? core::EvaluationStage::kNotEvaluated : core::EvaluationStage::kRuntime; @@ -3231,10 +3046,7 @@ sem::Call* Resolver::FunctionCall(const ast::CallExpression* expr, /* constant_value */ nullptr); target->AddCallSite(call); - - if (!validator_.FunctionCall(call, current_statement_)) { - return nullptr; - } + TINT_RET_IF(!validator_.FunctionCall(call, current_statement_)); if (current_function_) { // Note: Requires called functions to be resolved first. @@ -3249,11 +3061,14 @@ sem::Call* Resolver::FunctionCall(const ast::CallExpression* expr, // We inherit any referenced variables from the callee. for (auto* var : target->TransitivelyReferencedGlobals()) { current_function_->AddTransitivelyReferencedGlobal(var); + // Also track transitive unsized buffer requirements. + if (auto size = target->TransitivelyReferencedUnsizedBufferSize(var)) { + current_function_->AddTransitivelyReferencedUnsizedBufferSize(var, size.value()); + } } - if (!AliasAnalysis(call)) { - return nullptr; - } + TINT_RET_IF(!AliasAnalysis(call)); + TINT_RET_IF(!CheckBufferViews(call)); } return call; @@ -3288,9 +3103,7 @@ sem::ValueExpression* Resolver::Literal(const ast::LiteralExpression* literal) { [&](const ast::BoolLiteralExpression*) { return b.create(); }, // TINT_ICE_ON_NO_MATCH); - if (ty == nullptr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); const core::constant::Value* val = nullptr; auto stage = core::EvaluationStage::kConstant; @@ -3341,9 +3154,7 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { return Switch( resolved_node, // [&](sem::Variable* variable) -> sem::VariableUser* { - if (!DAWN_LIKELY(CheckNotTemplated("variable", ident))) { - return nullptr; - } + TINT_RET_IF(!DAWN_LIKELY(CheckNotTemplated("variable", ident))); auto stage = variable->Stage(); const core::constant::Value* value = variable->ConstantValue(); @@ -3371,14 +3182,13 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { auto symbol = ident->symbol; if (auto decl = loop_block->Decls().Get(symbol)) { if (decl->order >= loop_block->NumDeclsAtFirstContinue()) { - AddError(loop_block->FirstContinue()->source) + AddError(loop_block->FirstContinue()) << "continue statement bypasses declaration of '" << symbol.NameView() << "'"; - AddNote(decl->variable->Declaration()->source) + AddNote(decl->variable->Declaration()) << "identifier '" << symbol.NameView() << "' declared here"; - AddNote(expr->source) - << "identifier '" << symbol.NameView() - << "' referenced in continuing block here"; + AddNote(expr) << "identifier '" << symbol.NameView() + << "' referenced in continuing block here"; return nullptr; } } @@ -3395,7 +3205,7 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { } if (!current_function_ && variable->Declaration()->Is()) { // Use of a module-scope 'var' outside of a function. - AddError(expr->source) + AddError(expr) << style::Keyword("var ") << style::Variable(ident->symbol.NameView()) << " cannot be referenced at module-scope"; sem_.NoteDeclarationSource(variable->Declaration()); @@ -3412,9 +3222,7 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { }, [&](const core::type::Type* ty) -> sem::TypeExpression* { // User declared types cannot be templated. - if (!DAWN_LIKELY(CheckNotTemplated("type", ident))) { - return nullptr; - } + TINT_RET_IF(!DAWN_LIKELY(CheckNotTemplated("type", ident))); // Notify callers of all transitively referenced globals. if (auto* arr = ty->As()) { @@ -3432,18 +3240,14 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { return b.create(expr, current_statement_, ty); }, [&](const sem::Function* fn) -> sem::FunctionExpression* { - if (!DAWN_LIKELY(CheckNotTemplated("function", ident))) { - return nullptr; - } + TINT_RET_IF(!DAWN_LIKELY(CheckNotTemplated("function", ident))); return b.create(expr, current_statement_, fn); }); } if (auto builtin_ty = resolved->BuiltinType(); builtin_ty != core::BuiltinType::kUndefined) { auto* ty = BuiltinType(builtin_ty, ident); - if (!ty) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); return b.create(expr, current_statement_, ty); } @@ -3472,19 +3276,10 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { : nullptr; } - if (auto filterable = resolved->TextureFilterable(); - filterable != core::TextureFilterable::kUndefined) { - return CheckNotTemplated("texture filterable", ident) - ? b.create>( - expr, current_statement_, filterable) - : nullptr; - } - - if (auto filterable = resolved->SamplerFiltering(); - filterable != core::SamplerFiltering::kUndefined) { - return CheckNotTemplated("sampler filtering", ident) - ? b.create>( - expr, current_statement_, filterable) + if (auto major = resolved->Majorness(); major != core::Majorness::kUndefined) { + return CheckNotTemplated("majorness", ident) + ? b.create>(expr, current_statement_, + major) : nullptr; } @@ -3497,22 +3292,13 @@ sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) { sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpression* expr) { auto* object = sem_.GetVal(expr->object); - if (!object) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!object)); auto* object_ty = object->Type(); auto* const memory_view = object_ty->As(); - const core::type::Type* storage_ty = object_ty->UnwrapRef(); + const core::type::Type* storage_ty = object_ty; if (memory_view) { - if (memory_view->Is() && - !allowed_features_.features.contains(wgsl::LanguageFeature::kPointerCompositeAccess)) { - AddError(expr->source) - << "pointer composite access requires the pointer_composite_access language " - "feature, which is not allowed in the current environment"; - return nullptr; - } storage_ty = memory_view->StoreType(); } @@ -3536,7 +3322,7 @@ sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpressi } if (member == nullptr) { - AddError(expr->source) << "struct member " << symbol.NameView() << " not found"; + AddError(expr) << "struct member " << symbol.NameView() << " not found"; return nullptr; } @@ -3588,13 +3374,13 @@ sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpressi } if (swizzle.Back() >= vec->Width()) { - AddError(expr->member->source) << "invalid vector swizzle member"; + AddError(expr->member) << "invalid vector swizzle member"; return nullptr; } } if (size < 1 || size > 4) { - AddError(expr->member->source) << "invalid vector swizzle size"; + AddError(expr->member) << "invalid vector swizzle size"; return nullptr; } @@ -3603,7 +3389,7 @@ sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpressi auto is_xyzw = [](char c) { return c == 'x' || c == 'y' || c == 'z' || c == 'w'; }; if (!std::all_of(s.begin(), s.end(), is_rgba) && !std::all_of(s.begin(), s.end(), is_xyzw)) { - AddError(expr->member->source) + AddError(expr->member) << "invalid mixing of vector swizzle characters rgba with xyzw"; return nullptr; } @@ -3645,9 +3431,7 @@ sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpressi const core::constant::Value* val = nullptr; if (auto* obj_val = object->ConstantValue()) { auto res = const_eval_.Swizzle(ty, obj_val, swizzle); - if (res != Success) { - return nullptr; - } + TINT_RET_IF(res != Success); val = res.Get(); } return b.create(expr, ty, current_statement_, val, object, @@ -3655,7 +3439,7 @@ sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpressi }, [&](Default) { - AddError(expr->object->source) + AddError(expr->object) << "cannot index into expression of type '" << sem_.TypeNameOf(storage_ty) << "'"; return nullptr; }); @@ -3664,24 +3448,19 @@ sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpressi sem::ValueExpression* Resolver::Binary(const ast::BinaryExpression* expr) { const auto* lhs = sem_.GetVal(expr->lhs); const auto* rhs = sem_.GetVal(expr->rhs); - if (!lhs || !rhs) { - return nullptr; - } + TINT_RET_IF(!lhs || !rhs); // Load arguments if they are references lhs = Load(lhs); - if (!lhs) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!lhs)); + rhs = Load(rhs); - if (!rhs) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!rhs)); auto stage = core::EarliestStage(lhs->Stage(), rhs->Stage()); auto overload = intrinsic_table_.Lookup(expr->op, lhs->Type(), rhs->Type(), stage, false); if (overload != Success) { - AddError(expr->source) << overload.Failure(); + AddError(expr) << overload.Failure(); return nullptr; } @@ -3691,17 +3470,11 @@ sem::ValueExpression* Resolver::Binary(const ast::BinaryExpression* expr) { auto* lhs_ty = overload->parameters[0].type; auto* rhs_ty = overload->parameters[1].type; lhs = Materialize(lhs, lhs_ty); - if (!lhs) { - return nullptr; - } - rhs = Materialize(rhs, rhs_ty); - if (!rhs) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!lhs)); - if (!validator_.BinaryExpression(expr, expr->op, lhs, rhs)) { - return nullptr; - } + rhs = Materialize(rhs, rhs_ty); + TINT_RET_IF(DAWN_UNLIKELY(!rhs)); + TINT_RET_IF(!validator_.BinaryExpression(expr, expr->op, lhs, rhs)); const core::constant::Value* value = nullptr; if (not_evaluated_.Contains(expr)) { @@ -3721,16 +3494,11 @@ sem::ValueExpression* Resolver::Binary(const ast::BinaryExpression* expr) { // overload parameter types, and const-eval. Vector const_args{lhs->ConstantValue(), rhs->ConstantValue()}; // Implicit conversion (e.g. AInt -> AFloat) - if (!Convert(const_args[0], lhs_ty, lhs->Declaration()->source)) { - return nullptr; - } - if (!Convert(const_args[1], rhs_ty, rhs->Declaration()->source)) { - return nullptr; - } + TINT_RET_IF(!Convert(const_args[0], lhs_ty, lhs->Declaration()->source)); + TINT_RET_IF(!Convert(const_args[1], rhs_ty, rhs->Declaration()->source)); + auto r = (const_eval_.*const_eval_fn)(res_ty, const_args, expr->source); - if (r != Success) { - return nullptr; - } + TINT_RET_IF(r != Success); value = r.Get(); } else { // The arguments have constant values, but the operator cannot be const-evaluated. @@ -3745,9 +3513,8 @@ sem::ValueExpression* Resolver::Binary(const ast::BinaryExpression* expr) { sem::ValueExpression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) { const auto* expr = sem_.GetVal(unary->expr); - if (!expr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!expr)); + auto* expr_ty = expr->Type(); const core::type::Type* ty = nullptr; @@ -3759,9 +3526,8 @@ sem::ValueExpression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) { case core::UnaryOp::kAddressOf: if (auto* ref = expr_ty->As()) { if (ref->StoreType()->UnwrapRef()->IsHandle()) { - AddError(unary->expr->source) - << "cannot take the address of " << sem_.Describe(expr) - << " in handle address space"; + AddError(unary->expr) << "cannot take the address of " << sem_.Describe(expr) + << " in handle address space"; return nullptr; } @@ -3771,8 +3537,7 @@ sem::ValueExpression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) { sem_.TypeOf(array->object)->UnwrapPtrOrRef()->Is()) || (member && sem_.TypeOf(member->object)->UnwrapPtrOrRef()->Is())) { - AddError(unary->expr->source) - << "cannot take the address of a vector component"; + AddError(unary->expr) << "cannot take the address of a vector component"; return nullptr; } @@ -3781,8 +3546,7 @@ sem::ValueExpression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) { root_ident = expr->RootIdentifier(); } else { - AddError(unary->expr->source) - << "cannot take the address of " << sem_.Describe(expr); + AddError(unary->expr) << "cannot take the address of " << sem_.Describe(expr); return nullptr; } break; @@ -3793,38 +3557,32 @@ sem::ValueExpression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) { ptr->Access()); root_ident = expr->RootIdentifier(); } else { - AddError(unary->expr->source) << "cannot dereference expression of type " - << style::Type(sem_.TypeNameOf(expr_ty)); + AddError(unary->expr) << "cannot dereference expression of type " + << style::Type(sem_.TypeNameOf(expr_ty)); return nullptr; } break; default: { expr = Load(expr); - if (!expr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!expr)); stage = expr->Stage(); auto overload = intrinsic_table_.Lookup(unary->op, expr->Type(), stage); if (overload != Success) { - AddError(unary->source) << overload.Failure(); + AddError(unary) << overload.Failure(); return nullptr; } ty = overload->return_type; auto* param_ty = overload->parameters[0].type; expr = Materialize(expr, param_ty); - if (!expr) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!expr)); if (stage == core::EvaluationStage::kConstant) { if (auto const_eval_fn = overload->const_eval_fn) { auto r = (const_eval_.*const_eval_fn)(ty, Vector{expr->ConstantValue()}, expr->Declaration()->source); - if (r != Success) { - return nullptr; - } + TINT_RET_IF(r != Success); value = r.Get(); } else { stage = core::EvaluationStage::kRuntime; @@ -3849,15 +3607,15 @@ tint::Result Resolver::LocationAttribute(const ast::LocationAttribute* } if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) << style::Attribute("@location") << " must be an " - << style::Type("i32") << " or " << style::Type("u32") << " value"; + AddError(attr) << style::Attribute("@location") << " must be an " << style::Type("i32") + << " or " << style::Type("u32") << " value"; return Failure{}; } auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value < 0) { - AddError(attr->source) << style::Attribute("@location") << " value must be non-negative"; + AddError(attr) << style::Attribute("@location") << " value must be non-negative"; return Failure{}; } @@ -3874,15 +3632,15 @@ tint::Result Resolver::ColorAttribute(const ast::ColorAttribute* attr) } if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) << style::Attribute("@color") << " must be an " << style::Type("i32") - << " or " << style::Type("u32") << " value"; + AddError(attr) << style::Attribute("@color") << " must be an " << style::Type("i32") + << " or " << style::Type("u32") << " value"; return Failure{}; } auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value < 0) { - AddError(attr->source) << style::Attribute("@color") << " value must be non-negative"; + AddError(attr) << style::Attribute("@color") << " value must be non-negative"; return Failure{}; } @@ -3898,15 +3656,15 @@ tint::Result Resolver::BlendSrcAttribute(const ast::BlendSrcAttribute* } if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) << style::Attribute("@blend_src") << " value must be " - << style::Type("i32") << " or " << style::Type("u32"); + AddError(attr) << style::Attribute("@blend_src") << " value must be " << style::Type("i32") + << " or " << style::Type("u32"); return Failure{}; } auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value != 0 && value != 1) { - AddError(attr->source) << style::Attribute("@blend_src") << " value must be zero or one"; + AddError(attr) << style::Attribute("@blend_src") << " value must be zero or one"; return Failure{}; } @@ -3922,15 +3680,15 @@ tint::Result Resolver::BindingAttribute(const ast::BindingAttribute* a return Failure{}; } if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) << style::Attribute("@binding") << " must be an " - << style::Type("i32") << " or " << style::Type("u32") << " value"; + AddError(attr) << style::Attribute("@binding") << " must be an " << style::Type("i32") + << " or " << style::Type("u32") << " value"; return Failure{}; } auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value < 0) { - AddError(attr->source) << style::Attribute("@binding") << " value must be non-negative"; + AddError(attr) << style::Attribute("@binding") << " value must be non-negative"; return Failure{}; } return static_cast(value); @@ -3945,15 +3703,15 @@ tint::Result Resolver::GroupAttribute(const ast::GroupAttribute* attr) return Failure{}; } if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) << style::Attribute("@group") << " must be an " << style::Type("i32") - << " or " << style::Type("u32") << " value"; + AddError(attr) << style::Attribute("@group") << " must be an " << style::Type("i32") + << " or " << style::Type("u32") << " value"; return Failure{}; } auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value < 0) { - AddError(attr->source) << style::Attribute("@group") << " value must be non-negative"; + AddError(attr) << style::Attribute("@group") << " value must be non-negative"; return Failure{}; } return static_cast(value); @@ -3969,16 +3727,16 @@ tint::Result Resolver::InputAttachmentIndexAttribute( return Failure{}; } if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) << style::Attribute("@input_attachment_index") << " must be an " - << style::Type("i32") << " or " << style::Type("u32") << " value"; + AddError(attr) << style::Attribute("@input_attachment_index") << " must be an " + << style::Type("i32") << " or " << style::Type("u32") << " value"; return Failure{}; } auto const_value = materialized->ConstantValue(); auto value = const_value->ValueAs(); if (value < 0) { - AddError(attr->source) << style::Attribute("@input_attachment_index") - << " value must be non-negative"; + AddError(attr) << style::Attribute("@input_attachment_index") + << " value must be non-negative"; return Failure{}; } return static_cast(value); @@ -3996,10 +3754,10 @@ tint::Result Resolver::WorkgroupAttribute(const ast::Workgro Vector arg_tys; auto err_bad_expr = [&](const ast::Expression* value) { - AddError(value->source) << style::Attribute("@workgroup_size") - << " argument must be a constant or override-expression of type " - << style::Type("abstract-integer") << ", " << style::Type("i32") - << " or " << style::Type("u32"); + AddError(value) << style::Attribute("@workgroup_size") + << " argument must be a constant or override-expression of type " + << style::Type("abstract-integer") << ", " << style::Type("i32") << " or " + << style::Type("u32"); }; for (size_t i = 0; i < 3; i++) { @@ -4031,9 +3789,9 @@ tint::Result Resolver::WorkgroupAttribute(const ast::Workgro auto* common_ty = core::type::Type::Common(arg_tys); if (!common_ty) { - AddError(attr->source) << style::Attribute("@workgroup_size") - << " arguments must be of the same type, either " - << style::Type("i32") << " or " << style::Type("u32"); + AddError(attr) << style::Attribute("@workgroup_size") + << " arguments must be of the same type, either " << style::Type("i32") + << " or " << style::Type("u32"); return Failure{}; } @@ -4049,7 +3807,7 @@ tint::Result Resolver::WorkgroupAttribute(const ast::Workgro } if (auto* value = materialized->ConstantValue()) { if (value->ValueAs() < 1) { - AddError(values[i]->source) + AddError(values[i]) << style::Attribute("@workgroup_size") << " argument must be at least 1"; return Failure{}; } @@ -4063,7 +3821,7 @@ tint::Result Resolver::WorkgroupAttribute(const ast::Workgro for (size_t i = 1; i < 3; i++) { total_size *= static_cast(ws[i].value_or(1)); if (total_size > 0xffffffff) { - AddError(values[i]->source) << "total workgroup grid size cannot exceed 0xffffffff"; + AddError(values[i]) << "total workgroup grid size cannot exceed 0xffffffff"; return Failure{}; } } @@ -4075,10 +3833,10 @@ tint::Result Resolver::SubgroupSizeAttribute(const ast::SubgroupSizeAt auto value = attr->subgroup_size; auto err_bad_expr = [&]() { - AddError(attr->source) << style::Attribute("@subgroup_size") - << " argument must be a constant or override-expression of type " - << style::Type("abstract-integer") << ", " << style::Type("i32") - << " or " << style::Type("u32"); + AddError(attr) << style::Attribute("@subgroup_size") + << " argument must be a constant or override-expression of type " + << style::Type("abstract-integer") << ", " << style::Type("i32") << " or " + << style::Type("u32"); }; const auto* expr = ValueExpression(value); @@ -4110,14 +3868,13 @@ tint::Result Resolver::SubgroupSizeAttribute(const ast::SubgroupSizeAt uint32_t subgroup_size = 0u; if (auto* constant_value = materialized->ConstantValue()) { if (constant_value->ValueAs() < 1) { - AddError(attr->source) - << style::Attribute("@subgroup_size") << " argument must be at least 1"; + AddError(attr) << style::Attribute("@subgroup_size") << " argument must be at least 1"; return Failure{}; } subgroup_size = constant_value->ValueAs(); if (!IsPowerOfTwo(subgroup_size)) { - AddError(attr->source) - << style::Attribute("@subgroup_size") << " argument must be a power of 2"; + AddError(attr) << style::Attribute("@subgroup_size") + << " argument must be a power of 2"; return Failure{}; } } @@ -4153,7 +3910,7 @@ bool Resolver::DiagnosticControl(const ast::DiagnosticControl& control) { if (rule != wgsl::ChromiumDiagnosticRule::kUndefined) { validator_.DiagnosticFilters().Set(rule, control.severity); } else { - auto& warning = AddWarning(control.rule_name->source) + auto& warning = AddWarning(control.rule_name) << "unrecognized diagnostic rule " << style::Code("chromium.", name) << "\n"; tint::SuggestAlternativeOptions opts; @@ -4169,7 +3926,7 @@ bool Resolver::DiagnosticControl(const ast::DiagnosticControl& control) { if (rule != wgsl::CoreDiagnosticRule::kUndefined) { validator_.DiagnosticFilters().Set(rule, control.severity); } else { - auto& warning = AddWarning(control.rule_name->source) + auto& warning = AddWarning(control.rule_name) << "unrecognized diagnostic rule " << style::Code(name) << "\n"; tint::SuggestAlternatives(name, wgsl::kCoreDiagnosticRuleStrings, warning.message); } @@ -4181,8 +3938,8 @@ bool Resolver::Enable(const ast::Enable* enable) { Mark(ext); enabled_extensions_.Add(ext->name); if (!allowed_features_.extensions.contains(ext->name)) { - AddError(ext->source) << "extension " << style::Code(ext->name) - << " is not allowed in the current environment"; + AddError(ext) << "extension " << style::Code(ext->name) + << " is not allowed in the current environment"; return false; } } @@ -4192,8 +3949,8 @@ bool Resolver::Enable(const ast::Enable* enable) { bool Resolver::Requires(const ast::Requires* req) { for (auto feature : req->features) { if (!allowed_features_.features.contains(feature)) { - AddError(req->source) << "language feature " << style::Code(wgsl::ToString(feature)) - << " is not allowed in the current environment"; + AddError(req) << "language feature " << style::Code(wgsl::ToString(feature)) + << " is not allowed in the current environment"; return false; } } @@ -4211,10 +3968,7 @@ const core::type::Type* Resolver::TypeDecl(const ast::TypeDecl* named_type) { } else { TINT_UNREACHABLE() << "Unhandled TypeDecl"; } - - if (!result) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!result)); b.Sem().Add(named_type, result); return result; @@ -4224,7 +3978,13 @@ const core::type::ArrayCount* Resolver::ArrayCount(const ast::Expression* count_ const std::string count_kind = array ? "array count" : "buffer size"; // Evaluate the constant array count expression. const auto* count_sem = Materialize(sem_.GetVal(count_expr)); - if (!count_sem) { + TINT_RET_IF(DAWN_UNLIKELY(!count_sem)); + + auto* ty = count_sem->Type(); + if (!ty->IsIntegerScalar()) { + AddError(count_expr) << count_kind + << " must evaluate to an integer expression, but is type " + << style::Type(ty->FriendlyName()); return nullptr; } @@ -4245,17 +4005,9 @@ const core::type::ArrayCount* Resolver::ArrayCount(const ast::Expression* count_ case core::EvaluationStage::kConstant: { auto* count_val = count_sem->ConstantValue(); - if (auto* ty = count_val->Type(); !ty->IsIntegerScalar()) { - AddError(count_expr->source) - << count_kind << " must evaluate to a constant integer expression, but is type " - << style::Type(ty->FriendlyName()); - return nullptr; - } - int64_t count = count_val->ValueAs(); if (count < 1) { - AddError(count_expr->source) - << count_kind << " (" << count << ") must be greater than 0"; + AddError(count_expr) << count_kind << " (" << count << ") must be greater than 0"; return nullptr; } @@ -4263,9 +4015,9 @@ const core::type::ArrayCount* Resolver::ArrayCount(const ast::Expression* count_ } default: { - AddError(count_expr->source) << count_kind - << " must evaluate to a constant integer expression " - "or override variable"; + AddError(count_expr) << count_kind + << " must evaluate to a constant integer expression " + "or override variable"; return nullptr; } } @@ -4302,21 +4054,15 @@ sem::Array* Resolver::Array(const Source& array_source, } nest_depth_.Add(out, nest_depth); - if (!validator_.Array(out, el_source)) { - return nullptr; - } + TINT_RET_IF(!validator_.Array(out, el_source)); return out; } const core::type::Type* Resolver::Alias(const ast::Alias* alias) { auto* ty = Type(alias->type); - if (DAWN_UNLIKELY(!ty)) { - return nullptr; - } - if (DAWN_UNLIKELY(!validator_.Alias(alias))) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ty)); + TINT_RET_IF(DAWN_UNLIKELY(!validator_.Alias(alias))); return ty; } @@ -4329,15 +4075,12 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { // https://gpuweb.github.io/gpuweb/wgsl/#limits const size_t kMaxNumStructMembers = 16383; if (str->members.Length() > kMaxNumStructMembers) { - AddError(str->source) << style::Keyword("struct ") << style::Type(struct_name()) << " has " - << str->members.Length() << " members, maximum is " - << kMaxNumStructMembers; + AddError(str) << style::Keyword("struct ") << style::Type(struct_name()) << " has " + << str->members.Length() << " members, maximum is " << kMaxNumStructMembers; return nullptr; } - if (!validator_.NoDuplicateAttributes(str->attributes)) { - return nullptr; - } + TINT_RET_IF(!validator_.NoDuplicateAttributes(str->attributes)); if (!str->attributes.IsEmpty()) { ErrorInvalidAttribute(str->attributes[0], @@ -4363,24 +4106,21 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { Mark(member); Mark(member->name); if (auto added = member_map.Add(member->name->symbol, member); !added) { - AddError(member->source) - << "redefinition of " << style::Code(member->name->symbol.NameView()); - AddNote(added.value->source) << "previous definition is here"; + AddError(member) << "redefinition of " << style::Code(member->name->symbol.NameView()); + AddNote(added.value) << "previous definition is here"; return nullptr; } // Resolve member type auto type = Type(member->type); - if (!type) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!type)); members_nest_depth = std::max(members_nest_depth, NestDepth(type)); // validator_.Validate member type if (!validator_.IsPlain(type)) { - AddError(member->source) - << sem_.TypeNameOf(type) << " cannot be used as the type of a structure member"; + AddError(member) << sem_.TypeNameOf(type) + << " cannot be used as the type of a structure member"; return nullptr; } @@ -4388,9 +4128,7 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { uint64_t align = type->Align(); uint64_t size = type->Size(); - if (!validator_.NoDuplicateAttributes(member->attributes)) { - return nullptr; - } + TINT_RET_IF(!validator_.NoDuplicateAttributes(member->attributes)); bool has_align_attr = false; bool has_size_attr = false; @@ -4399,70 +4137,66 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { Mark(attribute); bool ok = Switch( attribute, // - [&](const ast::StructMemberAlignAttribute* attr) { + [&](const ast::StructMemberAlignAttribute* attr) -> bool { ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "@align"}; TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); auto* materialized = Materialize(ValueExpression(attr->expr)); - if (!materialized) { - return false; - } + TINT_RET_IF(!materialized); + if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) - << style::Attribute("@align") << " value must be an " - << style::Type("i32") << " or " << style::Type("u32"); + AddError(attr) << style::Attribute("@align") << " value must be an " + << style::Type("i32") << " or " << style::Type("u32"); return false; } auto const_value = materialized->ConstantValue(); if (!const_value) { - AddError(attr->source) + AddError(attr) << style::Attribute("@align") << " value must be constant expression"; return false; } auto value = const_value->ValueAs(); if (value <= 0 || !tint::IsPowerOfTwo(value)) { - AddError(attr->source) << style::Attribute("@align") - << " value must be a positive, power-of-two integer"; + AddError(attr) << style::Attribute("@align") + << " value must be a positive, power-of-two integer"; return false; } align = u32(value); has_align_attr = true; return true; }, - [&](const ast::StructMemberSizeAttribute* attr) { + [&](const ast::StructMemberSizeAttribute* attr) -> bool { ExprEvalStageConstraint constraint{core::EvaluationStage::kConstant, "@size"}; TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint); auto* materialized = Materialize(ValueExpression(attr->expr)); - if (!materialized) { - return false; - } + TINT_RET_IF(!materialized); + if (!materialized->Type()->IsAnyOf()) { - AddError(attr->source) - << style::Attribute("@size") << " value must be an " - << style::Type("i32") << " or " << style::Type("u32"); + AddError(attr) << style::Attribute("@size") << " value must be an " + << style::Type("i32") << " or " << style::Type("u32"); return false; } auto const_value = materialized->ConstantValue(); if (!const_value) { - AddError(attr->expr->source) + AddError(attr->expr) << style::Attribute("@size") << " value must be constant expression"; return false; } { auto value = const_value->ValueAs(); if (value <= 0) { - AddError(attr->source) + AddError(attr) << style::Attribute("@size") << " value must be a positive integer"; return false; } } auto value = const_value->ValueAs(); if (value < size) { - AddError(attr->source) + AddError(attr) << style::Attribute("@size") << " must be at least as big as the type's size (" << size << ")"; return false; @@ -4471,27 +4205,24 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { has_size_attr = true; return true; }, - [&](const ast::LocationAttribute* attr) { + [&](const ast::LocationAttribute* attr) -> bool { auto value = LocationAttribute(attr); - if (value != Success) { - return false; - } + TINT_RET_IF(value != Success); + attributes.location = value.Get(); return true; }, - [&](const ast::BlendSrcAttribute* attr) { + [&](const ast::BlendSrcAttribute* attr) -> bool { auto value = BlendSrcAttribute(attr); - if (value != Success) { - return false; - } + TINT_RET_IF(value != Success); + attributes.blend_src = value.Get(); return true; }, - [&](const ast::ColorAttribute* attr) { + [&](const ast::ColorAttribute* attr) -> bool { auto value = ColorAttribute(attr); - if (value != Success) { - return false; - } + TINT_RET_IF(value != Success); + attributes.color = value.Get(); return true; }, @@ -4504,10 +4235,9 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { attributes.interpolation = attr->interpolation; return true; }, - [&](const ast::InvariantAttribute* attr) { - if (!InvariantAttribute(attr)) { - return false; - } + [&](const ast::InvariantAttribute* attr) -> bool { + TINT_RET_IF(!InvariantAttribute(attr)); + attributes.invariant = true; return true; }, @@ -4516,16 +4246,14 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { StyledText{} << style::Keyword("struct") << " members"); return false; }); - if (!ok) { - return nullptr; - } + TINT_RET_IF(DAWN_UNLIKELY(!ok)); } offset = tint::RoundUp(align, offset); if (offset > std::numeric_limits::max()) { - AddError(member->source) - << "struct member offset (0x" << std::hex << offset << ") must not exceed 0x" - << std::hex << std::numeric_limits::max() << " bytes"; + AddError(member) << "struct member offset (0x" << std::hex << offset + << ") must not exceed 0x" << std::hex + << std::numeric_limits::max() << " bytes"; return nullptr; } @@ -4543,8 +4271,8 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { struct_size = tint::RoundUp(struct_align, struct_size); if (struct_size > std::numeric_limits::max()) { - AddError(str->source) << "struct size (0x" << std::hex << struct_size - << ") must not exceed 0xffffffff bytes"; + AddError(str) << "struct size (0x" << std::hex << struct_size + << ") must not exceed 0xffffffff bytes"; return nullptr; } if (DAWN_UNLIKELY(struct_align > std::numeric_limits::max())) { @@ -4572,17 +4300,15 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { auto stage = current_function_ ? current_function_->Declaration()->PipelineStage() : ast::PipelineStage::kNone; - if (!validator_.Structure(out, stage)) { - return nullptr; - } + TINT_RET_IF(!validator_.Structure(out, stage)); // Maximum nesting depth of composite types // https://gpuweb.github.io/gpuweb/wgsl/#limits const size_t nest_depth = 1 + members_nest_depth; if (nest_depth > kMaxNestDepthOfCompositeType) { - AddError(str->source) << style::Keyword("struct ") << style::Type(struct_name()) - << " has nesting depth of " << nest_depth << ", maximum is " - << kMaxNestDepthOfCompositeType; + AddError(str) << style::Keyword("struct ") << style::Type(struct_name()) + << " has nesting depth of " << nest_depth << ", maximum is " + << kMaxNestDepthOfCompositeType; return nullptr; } nest_depth_.Add(out, nest_depth); @@ -4592,21 +4318,18 @@ sem::Struct* Resolver::Structure(const ast::Struct* str) { sem::Statement* Resolver::ReturnStatement(const ast::ReturnStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto& behaviors = current_statement_->Behaviors(); behaviors = sem::Behavior::kReturn; const core::type::Type* value_ty = nullptr; if (auto* value = stmt->value) { const auto* expr = Load(ValueExpression(value)); - if (!expr) { - return false; - } + TINT_RET_IF(!expr); + if (auto* ret_ty = current_function_->ReturnType(); !ret_ty->Is()) { expr = Materialize(expr, ret_ty); - if (!expr) { - return false; - } + TINT_RET_IF(!expr); } value_ty = expr->Type(); } else { @@ -4623,13 +4346,12 @@ sem::Statement* Resolver::ReturnStatement(const ast::ReturnStatement* stmt) { sem::SwitchStatement* Resolver::SwitchStatement(const ast::SwitchStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto& behaviors = sem->Behaviors(); const auto* cond = Load(ValueExpression(stmt->condition)); - if (!cond) { - return false; - } + TINT_RET_IF(!cond); + // Each case clause will contribute behaviors. Switches must // have at least a default clause, so we'll always end up with // a non-empty behaviour set. @@ -4647,9 +4369,8 @@ sem::SwitchStatement* Resolver::SwitchStatement(const ast::SwitchStatement* stmt continue; } auto* sem_expr = ValueExpression(sel->expr); - if (!sem_expr) { - return false; - } + TINT_RET_IF(!sem_expr); + types.Push(sem_expr->Type()->UnwrapRef()); } } @@ -4660,9 +4381,7 @@ sem::SwitchStatement* Resolver::SwitchStatement(const ast::SwitchStatement* stmt common_ty = b.create(); } cond = Materialize(cond, common_ty); - if (!cond) { - return false; - } + TINT_RET_IF(!cond); // Handle switch body attributes. for (auto* attribute : stmt->body_attributes) { @@ -4675,22 +4394,17 @@ sem::SwitchStatement* Resolver::SwitchStatement(const ast::SwitchStatement* stmt StyledText{} << style::Keyword("switch") << " body"); return false; }); - if (!ok) { - return false; - } - } - if (!validator_.NoDuplicateAttributes(stmt->body_attributes)) { - return false; + TINT_RET_IF(!ok); } + TINT_RET_IF(!validator_.NoDuplicateAttributes(stmt->body_attributes)); Vector cases; cases.Reserve(stmt->body.Length()); for (auto* case_stmt : stmt->body) { Mark(case_stmt); auto* c = CaseStatement(case_stmt, common_ty); - if (!c) { - return false; - } + TINT_RET_IF(!c); + cases.Push(c); behaviors.Add(c->Behaviors()); sem->Cases().emplace_back(c); @@ -4709,13 +4423,11 @@ sem::SwitchStatement* Resolver::SwitchStatement(const ast::SwitchStatement* stmt sem::Statement* Resolver::VariableDeclStatement(const ast::VariableDeclStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { Mark(stmt->variable); auto* variable = Variable(stmt->variable, /* is_global */ false); - if (!variable) { - return false; - } + TINT_RET_IF(!variable); current_compound_statement_->AddDecl(variable->As()); @@ -4725,11 +4437,9 @@ sem::Statement* Resolver::VariableDeclStatement(const ast::VariableDeclStatement sem::Statement* Resolver::AssignmentStatement(const ast::AssignmentStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto* lhs = ValueExpression(stmt->lhs); - if (!lhs) { - return false; - } + TINT_RET_IF(!lhs); const bool is_phony_assignment = stmt->lhs->Is(); @@ -4749,9 +4459,7 @@ sem::Statement* Resolver::AssignmentStatement(const ast::AssignmentStatement* st rhs = Load(rhs); } - if (!rhs) { - return false; - } + TINT_RET_IF(!rhs); if (!is_phony_assignment) { RegisterStore(lhs); @@ -4773,11 +4481,10 @@ sem::Statement* Resolver::BreakStatement(const ast::BreakStatement* stmt) { sem::Statement* Resolver::BreakIfStatement(const ast::BreakIfStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto* cond = Load(ValueExpression(stmt->condition)); - if (!cond) { - return false; - } + TINT_RET_IF(!cond); + sem->SetCondition(cond); sem->Behaviors().Add(sem::Behavior::kBreak); @@ -4798,16 +4505,12 @@ sem::Statement* Resolver::CallStatement(const ast::CallStatement* stmt) { sem::Statement* Resolver::CompoundAssignmentStatement( const ast::CompoundAssignmentStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto* lhs = ValueExpression(stmt->lhs); - if (!lhs) { - return false; - } + TINT_RET_IF(!lhs); const auto* rhs = Load(ValueExpression(stmt->rhs)); - if (!rhs) { - return false; - } + TINT_RET_IF(!rhs); RegisterStore(lhs); @@ -4824,14 +4527,12 @@ sem::Statement* Resolver::CompoundAssignmentStatement( auto overload = intrinsic_table_.Lookup(stmt->op, lhs_type, rhs->Type(), stage, true); if (overload != Success) { - AddError(stmt->source) << overload.Failure(); + AddError(stmt) << overload.Failure(); return false; } rhs = Materialize(rhs, overload->parameters[1].type); - if (!rhs) { - return false; - } + TINT_RET_IF(!rhs); return validator_.Assignment(stmt, overload->return_type); }); @@ -4865,11 +4566,10 @@ sem::Statement* Resolver::DiscardStatement(const ast::DiscardStatement* stmt) { sem::Statement* Resolver::IncrementDecrementStatement( const ast::IncrementDecrementStatement* stmt) { auto* sem = b.create(stmt, current_compound_statement_, current_function_); - return StatementScope(stmt, sem, [&] { + return StatementScope(stmt, sem, [&]() -> bool { auto* lhs = ValueExpression(stmt->lhs); - if (!lhs) { - return false; - } + TINT_RET_IF(!lhs); + RegisterStore(lhs); return validator_.IncrementDecrementStatement(stmt); @@ -4893,7 +4593,7 @@ bool Resolver::ApplyAddressSpaceUsageToType(core::AddressSpace address_space, if (decl && !ApplyAddressSpaceUsageToType(address_space, const_cast(member->Type()), decl->type->source)) { - AddNote(member->Declaration()->source) + AddNote(member->Declaration()) << "while analyzing structure member " << sem_.TypeNameOf(str) << "." << member->Name().Name(); return false; @@ -4904,12 +4604,14 @@ bool Resolver::ApplyAddressSpaceUsageToType(core::AddressSpace address_space, if (auto* arr = ty->As()) { if (address_space != core::AddressSpace::kStorage) { - if (arr->Count()->Is()) { - AddError(usage) - << "runtime-sized arrays can only be used in the address space"; - return false; + // With buffer_view, runtime-sized arrays can appear in more locations. + if (!allowed_features_.features.contains(wgsl::LanguageFeature::kBufferView)) { + if (arr->Count()->Is()) { + AddError(usage) + << "runtime-sized arrays can only be used in the address space"; + return false; + } } - auto count = arr->ConstantCount(); if (count.has_value() && count.value() >= internal_limits::kMaxArrayElementCount) { AddError(usage) << "array count (" << count.value() << ") must be less than " @@ -4979,7 +4681,7 @@ SEM* Resolver::StatementScope(const ast::Statement* ast, SEM* sem, F&& callback) As(sem); // Helper to handle attributes that are supported on certain types of statement. - auto handle_attributes = [&](auto* stmt, sem::Statement* sem_stmt, const char* use) { + auto handle_attributes = [&](auto* stmt, sem::Statement* sem_stmt, const char* use) -> bool { for (auto* attribute : stmt->attributes) { Mark(attribute); bool ok = Switch( @@ -4989,13 +4691,10 @@ SEM* Resolver::StatementScope(const ast::Statement* ast, SEM* sem, F&& callback) ErrorInvalidAttribute(attribute, StyledText{} << use); return false; }); - if (!ok) { - return false; - } - } - if (!validator_.NoDuplicateAttributes(stmt->attributes)) { - return false; + TINT_RET_IF(!ok); } + TINT_RET_IF(!validator_.NoDuplicateAttributes(stmt->attributes)); + ApplyDiagnosticSeverities(sem_stmt); return true; }; @@ -5033,14 +4732,12 @@ SEM* Resolver::StatementScope(const ast::Statement* ast, SEM* sem, F&& callback) TINT_SCOPED_ASSIGNMENT(current_scoping_depth_, current_scoping_depth_ + 1); if (current_scoping_depth_ > kMaxStatementDepth) { - AddError(ast->source) << "statement nesting depth / chaining length exceeds limit of " - << kMaxStatementDepth; + AddError(ast) << "statement nesting depth / chaining length exceeds limit of " + << kMaxStatementDepth; return nullptr; } - if (!callback()) { - return nullptr; - } + TINT_RET_IF(!callback()); return sem; } @@ -5067,8 +4764,8 @@ void Resolver::ApplyDiagnosticSeverities(NODE* node) { bool Resolver::CheckNotTemplated(const char* use, const ast::Identifier* ident) { if (DAWN_UNLIKELY(ident->Is())) { - AddError(ident->source) << use << " " << style::Code(ident->symbol.NameView()) - << " does not take template arguments"; + AddError(ident) << use << " " << style::Code(ident->symbol.NameView()) + << " does not take template arguments"; if (auto resolved = dependencies_.resolved_identifiers.Get(ident)) { if (auto* ast_node = resolved->Node()) { sem_.NoteDeclarationSource(ast_node); @@ -5080,19 +4777,22 @@ bool Resolver::CheckNotTemplated(const char* use, const ast::Identifier* ident) } void Resolver::ErrorInvalidAttribute(const ast::Attribute* attr, StyledText use) { - AddError(attr->source) << style::Attribute("@", attr->Name()) << " is not valid for " << use; + AddError(attr) << style::Attribute("@", attr->Name()) << " is not valid for " << use; } +diag::Diagnostic& Resolver::AddError(const ast::Node* node) const { + return AddError(node->source); +} diag::Diagnostic& Resolver::AddError(const Source& source) const { return diagnostics_.AddError(source); } -diag::Diagnostic& Resolver::AddWarning(const Source& source) const { - return diagnostics_.AddWarning(source); +diag::Diagnostic& Resolver::AddWarning(const ast::Node* node) const { + return diagnostics_.AddWarning(node->source); } -diag::Diagnostic& Resolver::AddNote(const Source& source) const { - return diagnostics_.AddNote(source); +diag::Diagnostic& Resolver::AddNote(const ast::Node* node) const { + return diagnostics_.AddNote(node->source); } } // namespace tint::resolver diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.h b/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.h index 1895bf16a..3d657b1e5 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/resolver.h @@ -307,10 +307,17 @@ class Resolver { /// perform alias analysis. void RegisterLoad(const sem::ValueExpression* expr); + /// Register a bufferView or bufferArrayView call to track size compatibility. + void RegisterBufferView(const sem::Call* call, wgsl::BuiltinFn fn); + /// Perform pointer alias analysis for `call`. /// @returns true is the call arguments are free from aliasing issues, false otherwise. bool AliasAnalysis(const sem::Call* call); + /// Perform an analysis of buffer sizes for `call`. + /// @returns true if the call arguments are all appropriately sized. + bool CheckBufferViews(const sem::Call* call); + /// If `expr` is of a reference type, then Load will create and return a sem::Load node wrapping /// `expr`. If `expr` is not of a reference type, then Load will just return `expr`. const sem::ValueExpression* Load(const sem::ValueExpression* expr); @@ -568,10 +575,6 @@ class Resolver { /// @returns true on success, false on error bool AllocateOverridableConstantIds(); - /// Set the shadowing information on variable declarations. - /// @note this method must only be called after all semantic nodes are built. - void SetShadows(); - /// StatementScope() does the following: /// * Creates the AST -> SEM mapping. /// * Assigns `sem` to #current_statement_ @@ -607,13 +610,14 @@ class Resolver { void ErrorInvalidAttribute(const ast::Attribute* attr, StyledText use); /// @returns a new error message added to the program's diagnostics + diag::Diagnostic& AddError(const ast::Node* node) const; diag::Diagnostic& AddError(const Source& source) const; /// @returns a new warning message added to the program's diagnostics - diag::Diagnostic& AddWarning(const Source& source) const; + diag::Diagnostic& AddWarning(const ast::Node* node) const; /// @returns a new note message added to the program's diagnostics - diag::Diagnostic& AddNote(const Source& source) const; + diag::Diagnostic& AddNote(const ast::Node* node) const; /// @returns the core::type::Type for the builtin type @p builtin_ty with the identifier @p /// ident @@ -662,6 +666,12 @@ class Resolver { Hashset parameter_reads; }; + // BufferViewInfo tracks info for invalid buffer sizes. + struct BufferViewInfo { + uint64_t size = 0; + const ast::Node* node = nullptr; + }; + ProgramBuilder& b; diag::List& diagnostics_; core::constant::Eval const_eval_; @@ -681,6 +691,7 @@ class Resolver { Hashmap array_ctors_; Hashmap struct_ctors_; Hashmap subgroup_matrix_ctors_; + Hashmap buffer_view_sizes_; sem::Function* current_function_ = nullptr; sem::Statement* current_statement_ = nullptr; sem::CompoundStatement* current_compound_statement_ = nullptr; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.cc b/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.cc index aeebc66a5..86abc6961 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.cc @@ -27,6 +27,8 @@ #include "src/tint/lang/wgsl/resolver/sem_helper.h" +#include + #include "src/tint/lang/wgsl/resolver/incomplete_type.h" #include "src/tint/lang/wgsl/resolver/unresolved_identifier.h" #include "src/tint/lang/wgsl/sem/builtin_enum_expression.h" @@ -120,11 +122,8 @@ StyledText SemHelper::Describe(const sem::Expression* expr) const { [&](const sem::BuiltinEnumExpression* fmt) { text << "texel format " << style::Enum(fmt->Value()); }, - [&](const sem::BuiltinEnumExpression* filterable) { - text << "texture filterable " << style::Enum(filterable->Value()); - }, - [&](const sem::BuiltinEnumExpression* filtering) { - text << "sampler filtering " << style::Enum(filtering->Value()); + [&](const sem::BuiltinEnumExpression* major) { + text << "majorness " << style::Enum(major->Value()); }, [&](const UnresolvedIdentifier* ui) { auto name = ui->Identifier()->identifier->symbol.NameView(); @@ -138,10 +137,10 @@ StyledText SemHelper::Describe(const sem::Expression* expr) const { void SemHelper::ErrorUnexpectedIdent( const ast::Identifier* ident, std::string_view wanted, - tint::Slice suggestions /* = Empty */) const { + std::span suggestions /* = Empty */) const { auto name = ident->symbol.NameView(); AddError(ident->source) << "unresolved " << wanted << " " << style::Code(name); - if (!suggestions.IsEmpty()) { + if (!suggestions.empty()) { // Filter out suggestions that have a leading underscore. Vector filtered; for (auto str : suggestions) { @@ -152,14 +151,14 @@ void SemHelper::ErrorUnexpectedIdent( auto& note = AddNote(ident->source); SuggestAlternativeOptions opts; opts.alternatives_style = style::Enum; - SuggestAlternatives(name, filtered.Slice(), note.message, opts); + SuggestAlternatives(name, filtered.AsSpan(), note.message, opts); } } void SemHelper::ErrorUnexpectedExprKind( const sem::Expression* expr, std::string_view wanted, - tint::Slice suggestions /* = Empty */) const { + std::span suggestions /* = Empty */) const { if (auto* ui = expr->As()) { return ErrorUnexpectedIdent(ui->Identifier()->identifier, wanted, suggestions); } diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.h b/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.h index 357393326..8aaba024e 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/sem_helper.h @@ -28,15 +28,14 @@ #ifndef SRC_TINT_LANG_WGSL_RESOLVER_SEM_HELPER_H_ #define SRC_TINT_LANG_WGSL_RESOLVER_SEM_HELPER_H_ +#include #include #include "src/tint/lang/core/enums.h" #include "src/tint/lang/wgsl/program/program_builder.h" -#include "src/tint/lang/wgsl/resolver/dependency_graph.h" #include "src/tint/lang/wgsl/sem/builtin_enum_expression.h" #include "src/tint/lang/wgsl/sem/function_expression.h" #include "src/tint/lang/wgsl/sem/type_expression.h" -#include "src/tint/utils/containers/map.h" #include "src/tint/utils/diagnostic/diagnostic.h" #include "src/tint/utils/text/styled_text.h" @@ -149,64 +148,6 @@ class SemHelper { return core::AddressSpace::kUndefined; } - /// @param expr the semantic node - /// @returns nullptr if @p expr is nullptr, or @p expr cast to - /// sem::BuiltinEnumExpression if the cast is successful, otherwise an - /// error diagnostic is raised. - sem::BuiltinEnumExpression* AsTextureFilterable( - sem::Expression* expr) const { - if (DAWN_LIKELY(expr)) { - auto* enum_expr = expr->As>(); - if (DAWN_LIKELY(enum_expr)) { - return enum_expr; - } - ErrorUnexpectedExprKind(expr, "texture filterable", core::kTextureFilterableStrings); - } - return nullptr; - } - - /// GetTextureFilterable is a helper for obtaining the texture filterability for the given AST - /// expression. Raises an error diagnostic and returns core::TextureFilterable::kUndefined if - /// the semantic node is not a sem::BuiltinEnumExpression - /// @param ast the ast node to get the address space - /// @returns the sem node for @p ast - core::TextureFilterable GetTextureFilterable(const ast::Expression* ast) const { - auto* expr = AsTextureFilterable(Get(ast)); - if (DAWN_LIKELY(expr)) { - return expr->Value(); - } - return core::TextureFilterable::kUndefined; - } - - /// @param expr the semantic node - /// @returns nullptr if @p expr is nullptr, or @p expr cast to - /// sem::BuiltinEnumExpression if the cast is successful, otherwise an - /// error diagnostic is raised. - sem::BuiltinEnumExpression* AsSamplerFiltering( - sem::Expression* expr) const { - if (DAWN_LIKELY(expr)) { - auto* enum_expr = expr->As>(); - if (DAWN_LIKELY(enum_expr)) { - return enum_expr; - } - ErrorUnexpectedExprKind(expr, "sampler filtering", core::kSamplerFilteringStrings); - } - return nullptr; - } - - /// GetSamplerFiltering is a helper for obtaining the sampler filtering for the given AST - /// expression. Raises an error diagnostic and returns core::SamplerFiltering::kUndefined if - /// the semantic node is not a sem::BuiltinEnumExpression - /// @param ast the ast node to get the address space - /// @returns the sem node for @p ast - core::SamplerFiltering GetSamplerFiltering(const ast::Expression* ast) const { - auto* expr = AsSamplerFiltering(Get(ast)); - if (DAWN_LIKELY(expr)) { - return expr->Value(); - } - return core::SamplerFiltering::kUndefined; - } - /// @param expr the semantic node /// @returns nullptr if @p expr is nullptr, or @p expr cast to /// sem::BuiltinEnumExpression if the cast is successful, otherwise an @@ -286,7 +227,7 @@ class SemHelper { /// @param suggestions suggested valid identifiers void ErrorUnexpectedIdent(const ast::Identifier* ident, std::string_view wanted, - tint::Slice suggestions = Empty) const; + std::span suggestions = {}) const; /// Raises an error diagnostic that the expression @p got was not of the kind @p wanted. /// @param expr the expression @@ -294,7 +235,7 @@ class SemHelper { /// @param suggestions suggested valid identifiers void ErrorUnexpectedExprKind(const sem::Expression* expr, std::string_view wanted, - tint::Slice suggestions = Empty) const; + std::span suggestions = {}) const; /// If @p node is a module-scope type, variable or function declaration, then appends a note /// diagnostic where this declaration was declared, otherwise the function does nothing. diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/uniformity.cc b/3rdparty/dawn/src/tint/lang/wgsl/resolver/uniformity.cc index 92a14ecd7..3b9896f7d 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/uniformity.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/uniformity.cc @@ -32,7 +32,7 @@ #include "src/tint/lang/core/enums.h" #include "src/tint/lang/core/type/reference.h" -#include "src/tint/lang/core/type/swizzle_view.h" +#include "src/tint/lang/core/type/vector.h" #include "src/tint/lang/wgsl/program/program_builder.h" #include "src/tint/lang/wgsl/resolver/dependency_graph.h" #include "src/tint/lang/wgsl/sem/block_statement.h" @@ -68,23 +68,6 @@ namespace tint::resolver { namespace { -/// Unwraps `u->expr`'s chain of indirect (*) and address-of (&) expressions, returning the first -/// expression that is neither of these. -/// E.g. If `u` is `*(&(*(&p)))`, returns `p`. -const ast::Expression* UnwrapIndirectAndAddressOfChain(const ast::UnaryOpExpression* u) { - auto* e = u->expr; - while (true) { - auto* unary = e->As(); - if (unary && - (unary->op == core::UnaryOp::kIndirection || unary->op == core::UnaryOp::kAddressOf)) { - e = unary->expr; - } else { - break; - } - } - return e; -} - /// Scope of uniformity analysis. enum class UniformityScope : uint8_t { kAll, // workgroup/draw/subgroup @@ -593,17 +576,17 @@ class UniformityGraph { [&](const ast::AssignmentStatement* a) { if (a->lhs->Is()) { - auto [cf_r, _] = ProcessExpression(cf, a->rhs); - return cf_r; + ProcessExpression(cf, a->rhs); + return cf; } - auto [cf_l, v_l, ident] = ProcessLValueExpression(cf, a->lhs); - auto [cf_r, v_r] = ProcessExpression(cf_l, a->rhs); + auto [v_l, ident] = ProcessLValueExpression(cf, a->lhs); + auto* v_r = ProcessExpression(cf, a->rhs); v_l->AddEdge(v_r); // Update the variable node for the LHS variable. current_function_->variables.Set(ident, v_l); - return cf_r; + return cf; }, [&](const ast::BlockStatement* block) { @@ -736,7 +719,7 @@ class UniformityGraph { // above. auto* sem = sem_.Get(brk); - auto [_, v_cond] = ProcessExpression(cf, brk->condition); + auto* v_cond = ProcessExpression(cf, brk->condition); // Add a diagnostic node to capture the control flow change. auto* v = CreateNode({"break_if_stmt"}, brk); @@ -775,8 +758,8 @@ class UniformityGraph { }, [&](const ast::CallStatement* c) { - auto [cf1, _] = ProcessCall(cf, c->expr); - return cf1; + ProcessCall(cf, c->expr); + return cf; }, [&](const ast::CompoundAssignmentStatement* c) { @@ -785,13 +768,13 @@ class UniformityGraph { // *p = *p + b; // Evaluate the LHS. - auto [cf1, l1, ident] = ProcessLValueExpression(cf, c->lhs); + auto [l1, ident] = ProcessLValueExpression(cf, c->lhs); // Get the current value loaded from the LHS reference before evaluating the RHS. auto* lhs_load = current_function_->variables.Get(ident); // Evaluate the RHS. - auto [cf2, v2] = ProcessExpression(cf1, c->rhs); + auto* v2 = ProcessExpression(cf, c->rhs); // Create a node for the resulting value. auto* result = CreateNode({"binary_expr_result"}); @@ -804,7 +787,7 @@ class UniformityGraph { l1->AddEdge(result); current_function_->variables.Set(ident, l1); - return cf2; + return cf; }, [&](const ast::ContinueStatement* c) { @@ -877,7 +860,7 @@ class UniformityGraph { // Insert the condition at the start of the loop body. if (f->condition) { - auto [cf_cond, v] = ProcessExpression(cf_iter_start, f->condition); + auto* v = ProcessExpression(cf_iter_start, f->condition); auto* cf_condition_end = CreateNode({"for_condition_CFend"}, f); cf_condition_end->affects_control_flow = true; cf_condition_end->AddEdge(v); @@ -996,7 +979,7 @@ class UniformityGraph { // Insert the condition at the start of the loop body. { - auto [cf_cond, v] = ProcessExpression(cfx, w->condition); + auto* v = ProcessExpression(cfx, w->condition); auto* cf_condition_end = CreateNode({"while_condition_CFend"}, w); cf_condition_end->affects_control_flow = true; cf_condition_end->AddEdge(v); @@ -1040,7 +1023,7 @@ class UniformityGraph { [&](const ast::IfStatement* i) { auto* sem_if = sem_.Get(i); - auto [_, v_cond] = ProcessExpression(cf, i->condition); + auto* v_cond = ProcessExpression(cf, i->condition); // Add a diagnostic node to capture the control flow change. auto* v = CreateNode({"if_stmt"}, i); @@ -1127,14 +1110,14 @@ class UniformityGraph { // The increment/decrement statement `i++` is equivalent to `i = i + 1`. // Evaluate the LHS. - auto [cf1, l1, ident] = ProcessLValueExpression(cf, i->lhs); + auto [l1, ident] = ProcessLValueExpression(cf, i->lhs); // Get the current value loaded from the LHS reference. auto* lhs_load = current_function_->variables.Get(ident); // Create a node for the resulting value. auto* result = CreateNode({"incdec_result"}); - result->AddEdge(cf1); + result->AddEdge(cf); if (lhs_load) { result->AddEdge(lhs_load); } @@ -1143,7 +1126,7 @@ class UniformityGraph { l1->AddEdge(result); current_function_->variables.Set(ident, l1); - return cf1; + return cf; }, [&](const ast::LoopStatement* l) { @@ -1192,9 +1175,9 @@ class UniformityGraph { [&](const ast::ReturnStatement* r) { Node* cf_ret; if (r->value) { - auto [cf1, v] = ProcessExpression(cf, r->value); + auto* v = ProcessExpression(cf, r->value); current_function_->value_return->AddEdge(v); - cf_ret = cf1; + cf_ret = cf; } else { TINT_ASSERT(cf != nullptr); cf_ret = cf; @@ -1213,7 +1196,7 @@ class UniformityGraph { [&](const ast::SwitchStatement* s) { auto* sem_switch = sem_.Get(s); - auto [cfx, v_cond] = ProcessExpression(cf, s->condition); + auto* v_cond = ProcessExpression(cf, s->condition); // Add a diagnostic node to capture the control flow change. auto* v = CreateNode({"switch_stmt"}, s); @@ -1272,18 +1255,13 @@ class UniformityGraph { Node* node; auto* sem_var = sem_.Get(decl->variable); if (decl->variable->initializer) { - auto [cf1, v] = ProcessExpression(cf, decl->variable->initializer); - cf = cf1; + auto* v = ProcessExpression(cf, decl->variable->initializer); node = v; // Store if lhs is a partial pointer if (sem_var->Type()->Is()) { - auto* init = sem_.Get(decl->variable->initializer); - if (auto* unary_init = init->Declaration()->As()) { - auto* e = UnwrapIndirectAndAddressOfChain(unary_init); - if (e->Is()) { - current_function_->partial_ptrs.Add(sem_var); - } + if (IsPartialPointer(decl->variable->initializer)) { + current_function_->partial_ptrs.Add(sem_var); } } } else { @@ -1339,10 +1317,10 @@ class UniformityGraph { /// @param cf the input control flow node /// @param ident the identifier expression to process /// @param load_rule true if the load rule is being invoked on this identifier - /// @returns a pair of (control flow node, value node) - std::pair ProcessIdentExpression(Node* cf, - const ast::IdentifierExpression* ident, - bool load_rule = false) { + /// @returns the resulting value node + Node* ProcessIdentExpression(Node* cf, + const ast::IdentifierExpression* ident, + bool load_rule = false) { // Helper to check if the entry point attribute of `obj` indicates non-uniformity. auto has_nonuniform_entry_point_attribute = [&](auto* obj, auto* entry_point) { // Only the num_subgroups, num_workgroups and workgroup_id builtins, and subgroup_size @@ -1380,7 +1358,7 @@ class UniformityGraph { } } node->AddEdge(uniform ? cf : current_function_->may_be_non_uniform); - return std::make_pair(cf, node); + return node; } else { if (has_nonuniform_entry_point_attribute(param->Declaration(), user_func->Declaration())) { @@ -1388,7 +1366,7 @@ class UniformityGraph { } else { node->AddEdge(cf); } - return std::make_pair(cf, node); + return node; } } else { node->AddEdge(cf); @@ -1416,7 +1394,7 @@ class UniformityGraph { node->AddEdge(current_value); } - return std::make_pair(cf, node); + return node; } }, @@ -1428,7 +1406,7 @@ class UniformityGraph { } else { node->AddEdge(cf); } - return std::make_pair(cf, node); + return node; }, [&](const sem::LocalVariable* local) { @@ -1470,7 +1448,7 @@ class UniformityGraph { node->AddEdge(local_value); } - return std::make_pair(cf, node); + return node; }, TINT_ICE_ON_NO_MATCH); @@ -1480,10 +1458,8 @@ class UniformityGraph { /// @param cf the input control flow node /// @param expr the expression to process /// @param load_rule true if the load rule is being invoked on this expression - /// @returns a pair of (control flow node, value node) - std::pair ProcessExpression(Node* cf, - const ast::Expression* expr, - bool load_rule = false) { + /// @returns the resulting value node + Node* ProcessExpression(Node* cf, const ast::Expression* expr, bool load_rule = false) { if (sem_.Get(expr)) { // Set the load-rule flag to indicate that identifier expressions in this sub-tree // should add edges to the contents of the variables that they refer to. @@ -1496,22 +1472,22 @@ class UniformityGraph { [&](const ast::BinaryExpression* e) { if (e->IsLogical()) { // Short-circuiting binary operators are a special case. - auto [cf1, v1] = ProcessExpression(cf, e->lhs); + auto* v1 = ProcessExpression(cf, e->lhs); // Add a diagnostic node to capture the control flow change. auto* v1_cf = CreateNode({"short_circuit_op"}, e); v1_cf->affects_control_flow = true; v1_cf->AddEdge(v1); - auto [cf2, v2] = ProcessExpression(v1_cf, e->rhs); - return std::pair(cf, v2); + auto* v2 = ProcessExpression(v1_cf, e->rhs); + return v2; } else { - auto [cf1, v1] = ProcessExpression(cf, e->lhs); - auto [cf2, v2] = ProcessExpression(cf1, e->rhs); + auto* v1 = ProcessExpression(cf, e->lhs); + auto* v2 = ProcessExpression(cf, e->rhs); auto* result = CreateNode({"binary_expr_result"}, e); result->AddEdge(v1); result->AddEdge(v2); - return std::pair(cf2, result); + return result; } }, @@ -1522,15 +1498,15 @@ class UniformityGraph { }, [&](const ast::IndexAccessorExpression* i) { - auto [cf1, v1] = ProcessExpression(cf, i->object, load_rule); - auto [cf2, v2] = ProcessExpression(cf1, i->index); + auto* v1 = ProcessExpression(cf, i->index); + auto* v2 = ProcessExpression(cf, i->object, load_rule); auto* result = CreateNode({"index_accessor_result"}); result->AddEdge(v1); result->AddEdge(v2); - return std::pair(cf2, result); + return result; }, - [&](const ast::LiteralExpression*) { return std::make_pair(cf, cf); }, + [&](const ast::LiteralExpression*) { return cf; }, [&](const ast::MemberAccessorExpression* m) { return ProcessExpression(cf, m->object, load_rule); @@ -1543,33 +1519,33 @@ class UniformityGraph { TINT_ICE_ON_NO_MATCH); } - /// @param u unary expression with op == kIndirection - /// @returns true if `u` is an indirection unary expression that ultimately dereferences a - /// partial pointer, false otherwise. - bool IsDerefOfPartialPointer(const ast::UnaryOpExpression* u) { - TINT_ASSERT(u->op == core::UnaryOp::kIndirection); - - // To determine if we're dereferencing a partial pointer, unwrap *& - // chains; if the final expression is an identifier, see if it's a - // partial pointer. If it's not an identifier, then it must be an - // index/member accessor expression, and thus a partial pointer. - auto* e = UnwrapIndirectAndAddressOfChain(u); - if (auto* var_user = sem_.Get(e)) { - if (current_function_->partial_ptrs.Contains(var_user->Variable())) { - return true; + /// @param expr expression + /// @returns true if `expr` is derived from a partial pointer, false otherwise. + bool IsPartialPointer(const ast::Expression* expr) { + // First unwraps the chain of indirect (*) and address-of (&) expressions, returning the + // first expression that is neither of these. + // e.g. If `expr` is `*(&(*(&p)))`, returns `p`. + while (true) { + auto* unary = expr->As(); + if (unary && (unary->op == core::UnaryOp::kIndirection || + unary->op == core::UnaryOp::kAddressOf)) { + expr = unary->expr; + } else { + break; } - } else { - TINT_ASSERT(e->Is()); - return true; } - return false; + + // The final expression is a partial pointer iff either of the following are true: + // * It is an identifier that has been marked as a partial pointer. + // * It is an index/member accessor expression. + if (auto* var_user = sem_.Get(expr)) { + return current_function_->partial_ptrs.Contains(var_user->Variable()); + } + return expr->Is(); } /// LValue holds the Nodes returned by ProcessLValueExpression() struct LValue { - /// The control-flow node for an LValue expression - Node* cf = nullptr; - /// The new value node for an LValue expression Node* new_val = nullptr; @@ -1582,7 +1558,7 @@ class UniformityGraph { /// @param expr the expression to process /// @param is_dereferencing `true` if we are dereferencing a pointer /// @param is_partial_reference `true` if we are referencing a subset of a variable - /// @returns a tuple of (control flow node, variable node, root identifier) + /// @returns a tuple of (variable node, root identifier) LValue ProcessLValueExpression(Node* cf, const ast::Expression* expr, bool is_dereferencing = false, @@ -1599,7 +1575,7 @@ class UniformityGraph { // be dereferencing here. TINT_ASSERT(!is_dereferencing); - return LValue{cf, current_function_->may_be_non_uniform, nullptr}; + return LValue{current_function_->may_be_non_uniform, nullptr}; }, [&](const sem::LocalVariable* local) { Node* value = nullptr; @@ -1623,7 +1599,7 @@ class UniformityGraph { value = CreateNode({NameFor(i), "_lvalue"}); } - return LValue{cf, value, root_ident}; + return LValue{value, root_ident}; }, [&](const sem::Parameter* param) { // Parameters can only be LValues when we are dereferencing a pointer. @@ -1635,7 +1611,7 @@ class UniformityGraph { // The uniformity of the value depends on the pointer itself. value->AddEdge(current_function_->parameters[param->Index()].value); - return LValue{cf, value, param}; + return LValue{value, param}; }, [&](Default) -> LValue { TINT_ICE() << "unknown lvalue identifier expression type: " @@ -1660,12 +1636,11 @@ class UniformityGraph { is_dereferencing = is_dereferencing || sem_.GetVal(i->object)->Type()->Is(); - auto [cf1, l1, root_ident] = - ProcessLValueExpression(cf, i->object, is_dereferencing, - /*is_partial_reference*/ true); - auto [cf2, v2] = ProcessExpression(cf1, i->index); - l1->AddEdge(v2); - return LValue{cf2, l1, root_ident}; + auto* v1 = ProcessExpression(cf, i->index); + auto [l2, root_ident] = ProcessLValueExpression(cf, i->object, is_dereferencing, + /*is_partial_reference*/ true); + l2->AddEdge(v1); + return LValue{l2, root_ident}; }, [&](const ast::MemberAccessorExpression* m) { @@ -1674,8 +1649,28 @@ class UniformityGraph { is_dereferencing = is_dereferencing || sem_.GetVal(m->object)->Type()->Is(); + // An assignment to a full swizzle view (which updates all components of the object + // vector) is a full assignment. + bool is_full_swizzle = false; + if (auto* swizzle = sem_.Get(m)) { + // Collapse chained swizzles if necessary. + sem::CollapsedSwizzle collapsed = sem::CollapseLhsSwizzle(swizzle); + auto* vec_type = + collapsed.vector->Type()->UnwrapPtrOrRef()->As(); + TINT_ASSERT(vec_type); + + // Duplicated elements are not permitted on the LHS of a swizzle assignment, so + // comparing lengths is sufficient to determine whether it is a full/partial + // swizzle. + if (collapsed.indices.Length() == vec_type->Width()) { + is_full_swizzle = true; + } + } + + is_partial_reference = is_partial_reference || !is_full_swizzle; + return ProcessLValueExpression(cf, m->object, is_dereferencing, - /*is_partial_reference*/ true); + is_partial_reference); }, [&](const ast::UnaryOpExpression* u) { @@ -1683,31 +1678,37 @@ class UniformityGraph { return ProcessLValueExpression( cf, u->expr, /* is_dereferencing */ true, - /* is_partial_reference */ is_partial_reference || - IsDerefOfPartialPointer(u)); + /* is_partial_reference */ is_partial_reference || IsPartialPointer(u)); } return ProcessLValueExpression(cf, u->expr, /* is_dereferencing */ false, /* is_partial_reference */ is_partial_reference); }, + [&](const ast::CallExpression* c) { + // This must be a bufferView/bufferArrayView call. + auto* sem = sem_.GetVal(c->args[0]); + auto* root_ident = sem->RootIdentifier(); + auto v1 = ProcessCall(cf, c); + return LValue{v1, root_ident}; + }, + TINT_ICE_ON_NO_MATCH); } /// Process a function call expression. /// @param cf the input control flow node /// @param call the function call to process - /// @returns a pair of (control flow node, value node) - std::pair ProcessCall(Node* cf, const ast::CallExpression* call) { + /// @returns the resulting value node + Node* ProcessCall(Node* cf, const ast::CallExpression* call) { std::string name = NameFor(call->target); // Process call arguments - Node* cf_last_arg = cf; Vector args; Vector ptrarg_contents; ptrarg_contents.Resize(call->args.Length()); for (size_t i = 0; i < call->args.Length(); i++) { - auto [cf_i, arg_i] = ProcessExpression(cf_last_arg, call->args[i]); + auto* arg_i = ProcessExpression(cf, call->args[i]); // Capture the index of this argument in a new node. // Note: This is an additional node that isn't described in the specification, for the @@ -1739,18 +1740,16 @@ class UniformityGraph { ptrarg_contents[i] = arg_contents; } - cf_last_arg = cf_i; args.Push(arg_node); } // Note: This is an additional node that isn't described in the specification, for the // purpose of providing diagnostic information. Node* call_node = CreateNode({name, "_call"}, call); - call_node->AddEdge(cf_last_arg); + call_node->AddEdge(cf); Node* result = CreateNode({name, "_return_value"}, call); result->type = Node::kFunctionCallReturnValue; - Node* cf_after = CreateNode({"CF_after_", name}, call); auto default_severity = kUniformityFailuresAsError ? wgsl::DiagnosticSeverity::kError : wgsl::DiagnosticSeverity::kWarning; @@ -1862,13 +1861,11 @@ class UniformityGraph { }, // TINT_ICE_ON_NO_MATCH); - cf_after->AddEdge(call_node); - if (function_tag == ReturnValueMayBeNonUniform) { result->AddEdge(current_function_->may_be_non_uniform); } - result->AddEdge(cf_after); + result->AddEdge(call_node); // For each argument, add edges based on parameter tags. for (size_t i = 0; i < args.Length(); i++) { @@ -1931,6 +1928,14 @@ class UniformityGraph { // Update the current stored value for this pointer argument. auto* root_ident = sem_arg->RootIdentifier(); TINT_ASSERT(root_ident); + + // Check if the argument is a partial pointer. If the previous contents were + // non-uniform, a partial assignment will not make it uniform. + auto* old_value = current_function_->variables.Get(root_ident); + if (IsPartialPointer(call->args[i]) && old_value) { + ptr_result->AddEdge(old_value); + } + current_function_->variables.Set(root_ident, ptr_result); } } else { @@ -1980,7 +1985,7 @@ class UniformityGraph { current_function_->RequiredToBeUniform(callsite_tag.severity)->AddEdge(call_node); } - return {cf_after, result}; + return result; } /// Traverse a graph starting at `source`, inserting all visited nodes into `reachable` and diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.cc b/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.cc index fff0f5fff..1eb276ab1 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.cc @@ -27,7 +27,9 @@ #include "src/tint/lang/wgsl/resolver/validator.h" +#include #include +#include #include #include #include @@ -298,11 +300,10 @@ bool Validator::Enables(VectorRef enables) const { } } - if (enabled_extensions_.Contains(wgsl::Extension::kChromiumExperimentalSubgroupSizeControl) && + if (enabled_extensions_.Contains(wgsl::Extension::kSubgroupSizeControl) && !enabled_extensions_.Contains(wgsl::Extension::kSubgroups)) { - AddError(source_of(wgsl::Extension::kChromiumExperimentalSubgroupSizeControl)) - << "extension " - << style::Code(wgsl::Extension::kChromiumExperimentalSubgroupSizeControl) + AddError(source_of(wgsl::Extension::kSubgroupSizeControl)) + << "extension " << style::Code(wgsl::Extension::kSubgroupSizeControl) << " cannot be used without extension " << style::Code(wgsl::Extension::kSubgroups); return false; } @@ -375,23 +376,7 @@ bool Validator::Pointer(const ast::TemplatedIdentifier* a, const core::type::Poi bool Validator::StorageTexture(const core::type::StorageTexture* t, const Source& source) const { switch (t->Access()) { case core::Access::kRead: - if (!allowed_features_.features.contains( - wgsl::LanguageFeature::kReadonlyAndReadwriteStorageTextures)) { - AddError(source) << "read-only storage textures require the " - "readonly_and_readwrite_storage_textures language feature, " - "which is not allowed in the current environment"; - return false; - } - break; case core::Access::kReadWrite: - if (!allowed_features_.features.contains( - wgsl::LanguageFeature::kReadonlyAndReadwriteStorageTextures)) { - AddError(source) << "read-write storage textures require the " - "readonly_and_readwrite_storage_textures language feature, " - "which is not allowed in the current environment"; - return false; - } - break; case core::Access::kWrite: break; case core::Access::kUndefined: @@ -418,14 +403,6 @@ bool Validator::SampledTexture(const core::type::SampledTexture* t, const Source AddError(source) << "texture_2d: type must be f32, i32 or u32"; return false; } - - if (t->Filterable() != core::TextureFilterable::kUndefined && - !t->Type()->IsAnyOf()) { - AddError(source) << "texture filterability only applies to float textures, got '" - << sem_.TypeNameOf(t->Type()) << "'"; - return false; - } - return true; } @@ -650,29 +627,6 @@ bool Validator::AddressSpaceLayout(const core::type::Type* store_ty, return false; } - // Validate that member is at a valid byte offset - if (m->Offset() % required_align != 0) { - AddError(m->Declaration()->source) - << "the offset of a struct member of type " - << style::Type(m->Type()->UnwrapRef()->FriendlyName()) << " in address space " - << style::Enum(address_space) << " must be a multiple of " << required_align - << " bytes, but " << style::Variable(member_name_of(m)) - << " is currently at offset " << m->Offset() << ". Consider setting " - << style::Attribute("@align") << style::Code("(", required_align, ")") - << " on this member"; - - AddNote(str_source) << "see layout of struct:\n" << str->Layout(); - - if (auto* member_str = m->Type()->As()) { - AddNote(member_str->Declaration()->name->source) - << "and layout of struct member:\n" - << member_str->Layout(); - } - - note_usage(); - return false; - } - // For uniform buffers, validate that the number of bytes between the previous member of // type struct and the current is a multiple of 16 bytes. auto* const prev_member = (i == 0) ? nullptr : str->Members()[i - 1]; @@ -896,14 +850,19 @@ bool Validator::Var(const sem::Variable* v) const { } } - if (auto* buffer = store_ty->As()) { - if (buffer->Count()->Is() && - (v->AddressSpace() == core::AddressSpace::kUniform || - v->AddressSpace() == core::AddressSpace::kWorkgroup)) { - AddError(var->source) << "buffer type must be sized in " - << style::Enum(v->AddressSpace()) << " address space"; - return false; + // With buffer_view, this is alternative validation to runtime-sized array checks. + if (allowed_features_.features.contains(wgsl::LanguageFeature::kBufferView)) { + if (v->AddressSpace() != core::AddressSpace::kStorage && + v->AddressSpace() != core::AddressSpace::kHandle) { + if (!store_ty->HasFixedFootprint()) { + AddError(var->source) << "variables in " << style::Enum(v->AddressSpace()) + << " address space must have a fixed footprint"; + return false; + } } + } + + if (auto* buffer = store_ty->As()) { if (!(buffer->Count()->Is() || buffer->Count()->Is()) && v->AddressSpace() != core::AddressSpace::kWorkgroup) { @@ -1002,28 +961,19 @@ bool Validator::Parameter(const sem::Variable* var) const { auto* decl = var->Declaration(); if (auto* ref = var->Type()->As()) { - bool ok = false; - auto sc = ref->AddressSpace(); switch (sc) { case core::AddressSpace::kFunction: case core::AddressSpace::kPrivate: - ok = true; - break; case core::AddressSpace::kImmediate: case core::AddressSpace::kStorage: case core::AddressSpace::kUniform: case core::AddressSpace::kWorkgroup: - ok = allowed_features_.features.contains( - wgsl::LanguageFeature::kUnrestrictedPointerParameters); break; default: - break; - } - if (!ok) { - AddError(decl->source) << "function parameter of pointer type cannot be in " - << style::Enum(sc) << " address space"; - return false; + AddError(decl->source) << "function parameter of pointer type cannot be in " + << style::Enum(sc) << " address space"; + return false; } } @@ -1418,12 +1368,10 @@ bool Validator::Function(const sem::Function* func, ast::PipelineStage stage) co return true; }, [&](const ast::SubgroupSizeAttribute*) { - if (!enabled_extensions_.Contains( - wgsl::Extension::kChromiumExperimentalSubgroupSizeControl)) { + if (!enabled_extensions_.Contains(wgsl::Extension::kSubgroupSizeControl)) { AddError(attr->source) << "use of " << style::Attribute("@subgroup_size") - << " requires enabling extension " - << style::Code("chromium_experimental_subgroup_size_control"); + << " requires enabling extension " << style::Code("subgroup_size_control"); return false; } if (decl->PipelineStage() != ast::PipelineStage::kCompute) { @@ -2070,6 +2018,12 @@ bool Validator::BuiltinCall(const sem::Call* call) const { return false; } } + if (fn->Fn() == wgsl::BuiltinFn::kSubgroupMatrixLoad || + fn->Fn() == wgsl::BuiltinFn::kSubgroupMatrixStore) { + if (!CheckSubgroupMatrixOpOffset(fn, call->Arguments()[0], call->Arguments()[1])) { + return false; + } + } } return true; @@ -2160,47 +2114,150 @@ bool Validator::BufferView(const sem::Call* call) const { << "return type of " << builtin->str() << " cannot contain an atomic type"; return false; } + if (builtin->Fn() == wgsl::BuiltinFn::kBufferArrayView) { + if (ret_store_type->HasFixedFootprint()) { + AddError(call->Declaration()->source) + << "return type of " << builtin->str() << " cannot have a fixed footprint"; + return false; + } + } if (!CheckTypeAccessAddressSpace(ret_store_type, ret_ptr_type->Access(), ret_ptr_type->AddressSpace(), call->Declaration()->source)) { return false; } - TINT_ASSERT(call->Arguments().Length() == 2); + TINT_ASSERT(builtin->Fn() == wgsl::BuiltinFn::kBufferView ? call->Arguments().Length() == 2 + : call->Arguments().Length() == 3); + + uint64_t ret_min_size = 0; + uint64_t ret_offset = 0; + uint64_t ret_stride = 0; + if (ret_store_type->HasFixedFootprint()) { + ret_min_size = ret_store_type->Size(); + } else { + if (const auto* str_ty = ret_store_type->As()) { + const auto* last = str_ty->Members().Back(); + const auto* last_ty = last->Type(); + TINT_ASSERT(last_ty->Is()); + ret_offset = last->Offset(); + ret_stride = last_ty->As()->ImplicitStride(); + } else { + TINT_ASSERT(ret_store_type->Is()); + ret_stride = ret_store_type->As()->ImplicitStride(); + } + ret_min_size = ret_offset + ret_stride; + } auto* buffer_ptr = call->Arguments()[0]; auto* buffer_type = buffer_ptr->Type()->As()->StoreType()->As(); auto* offset = call->Arguments()[1]; - auto* constant_value = offset->ConstantValue(); - if (!constant_value || !offset->Type()->IsIntegerScalar()) { + auto* offset_constant_value = offset->ConstantValue(); + uint64_t offset_value = 0; + if (offset_constant_value) { + if (offset->Type()->IsUnsignedIntegerScalar()) { + offset_value = offset_constant_value->ValueAs(); + } else { + TINT_ASSERT(offset->Type()->IsSignedIntegerScalar()); + int32_t ivalue = offset_constant_value->ValueAs(); + if (ivalue < 0) { + AddError(offset->Declaration()->source) + << "the offset argument of " << builtin->str() << " must be non-negative"; + return false; + } + offset_value = static_cast(ivalue); + } + if (offset_value % ret_store_type->Align() != 0) { + AddError(offset->Declaration()->source) + << "the offset argument of " << builtin->str() + << " must evenly divide the alignment of the return type (" + << ret_store_type->Align() << ")"; + return false; + } + } + + auto count = buffer_type->ConstantCount(); + if (builtin->Fn() == wgsl::BuiltinFn::kBufferView) { + if (offset_value + ret_min_size > std::numeric_limits::max()) { + AddError(offset->Declaration()->source) + << "the offset argument of " << builtin->str() + << " plus the minimum size of the return type must not overflow a 32-bit unsigned " + "integer"; + return false; + } + if (count != std::nullopt && offset_value + ret_min_size > count.value()) { + AddError(offset->Declaration()->source) + << "the offset argument of " << builtin->str() + << " plus the minimum size of the return type must be less than or equal to the " + "buffer size"; + return false; + } + return true; } - uint32_t value; - if (offset->Type()->IsUnsignedIntegerScalar()) { - value = constant_value->ValueAs(); - } else { - int32_t ivalue = constant_value->ValueAs(); - if (ivalue < 0) { - AddError(offset->Declaration()->source) - << "the offset argument of " << builtin->str() << " must be non-negative"; + // bufferArrayView specific checks + // Return type must not have a fixed footprint. + uint64_t size_value = 0; + auto* size = call->Arguments()[2]; + auto* size_constant_value = size->ConstantValue(); + if (size_constant_value) { + size_value = std::numeric_limits::max(); + if (size->Type()->IsUnsignedIntegerScalar()) { + size_value = size_constant_value->ValueAs(); + } else { + TINT_ASSERT(size->Type()->IsSignedIntegerScalar()); + int32_t ivalue = size_constant_value->ValueAs(); + if (ivalue < 0) { + AddError(size->Declaration()->source) + << "the size argument of " << builtin->str() << " must be non-negative"; + return false; + } + size_value = static_cast(ivalue); + } + + if (size_value < ret_min_size) { + AddError(size->Declaration()->source) + << "the size argument (" << size_value << " bytes) of " << builtin->str() + << " must be large enough to include one element of the runtime-sized array (" + << ret_min_size << " bytes)"; + return false; + } + + if ((size_value - ret_offset) % ret_stride != 0) { + AddError(size->Declaration()->source) + << "the size argument (" << size_value << " bytes) of " << builtin->str() + << " minus the return type offset (" << ret_offset + << " bytes) must be evenly divisible by the stride of the runtime-sized array (" + << ret_stride << " bytes)"; return false; } - value = static_cast(ivalue); } - if (value % ret_store_type->Align() != 0) { - AddError(offset->Declaration()->source) - << "the offset argument of " << builtin->str() - << " must evenly divide the alignment of the return type (" << ret_store_type->Align() - << ")"; + + if (offset_value + size_value + ret_min_size > std::numeric_limits::max()) { + AddError(call->Declaration()->source) + << "the offset and size arguments of " << builtin->str() + << " plus the minimum return type size must not overflow a 32-bit unsigned integer"; return false; } - auto count = buffer_type->ConstantCount(); - if (count != std::nullopt && value + ret_store_type->Size() >= count.value()) { - AddError(offset->Declaration()->source) - << "the offset argument of " << builtin->str() - << " plus the size of the return type must be smaller than the buffer size"; + if (count != std::nullopt && + (offset_value + std::max(size_value, ret_min_size) > count.value())) { + std::string msg; + std::ostringstream str(msg); + str << "the buffer (" << count.value() + << " bytes) must be large enough to include one element of the runtime-sized array (" + << ret_min_size << " bytes)"; + if (offset_value != 0 || size_value != 0) { + str << " with the given"; + } + if (offset_value != 0) { + str << " offset (" << offset_value << " bytes)"; + } + if (size_value != 0) { + str << (offset_value != 0 ? " and" : "") << " size (" << size_value << " bytes)"; + } + AddError(call->Declaration()->source) << str.str(); return false; } @@ -2440,14 +2497,18 @@ bool Validator::FunctionCall(const sem::Call* call, sem::Statement* current_stat auto* param_store_type = param_ptr_type->StoreType(); if (arg_store_type->Is() && param_store_type->Is()) { - const bool param_unsized = param_store_type->As() - ->Count() - ->Is(); - auto arg_count = arg_store_type->As()->ConstantCount(); - auto param_count = param_store_type->As()->ConstantCount(); + auto* arg_buffer_ty = arg_store_type->As(); + auto* param_buffer_ty = param_store_type->As(); + const bool param_unsized = + param_buffer_ty->Count()->Is(); + const bool both_constant = + arg_buffer_ty->Count()->Is() && + param_buffer_ty->Count()->Is(); + auto arg_count = arg_buffer_ty->ConstantCount().value_or(0); + auto param_count = param_buffer_ty->ConstantCount().value_or(0); if (arg_ptr_type->AddressSpace() == param_ptr_type->AddressSpace() && arg_ptr_type->Access() == param_ptr_type->Access() && - (param_unsized || arg_count.value_or(0) > param_count.value_or(0))) { + (param_unsized || (both_constant && arg_count > param_count))) { // Any buffer argument can match an unsized buffer parameter. // A larger buffer argument can match a smaller buffer parameter. allow_mismatch = true; @@ -2462,32 +2523,6 @@ bool Validator::FunctionCall(const sem::Call* call, sem::Statement* current_stat << style::Type(sem_.TypeNameOf(arg_type)); return false; } - - if (param_type->Is() && - !allowed_features_.features.contains( - wgsl::LanguageFeature::kUnrestrictedPointerParameters)) { - // https://gpuweb.github.io/gpuweb/wgsl/#function-restriction - // Each argument of pointer type to a user-defined function must have the same memory - // view as its root identifier. - // We can validate this by just comparing the store type of the argument with that of - // its root identifier, as these will match iff the memory view is the same. - auto* arg_store_type = arg_type->As()->StoreType(); - auto* root = call->Arguments()[i]->RootIdentifier(); - auto* root_ptr_ty = root->Type()->As(); - auto* root_ref_ty = root->Type()->As(); - TINT_ASSERT(root_ptr_ty || root_ref_ty); - const core::type::Type* root_store_type; - if (root_ptr_ty) { - root_store_type = root_ptr_ty->StoreType(); - } else { - root_store_type = root_ref_ty->StoreType(); - } - if (root_store_type != arg_store_type) { - AddError(arg_expr->source) << "arguments of pointer type must not point to a " - "subset of the originating variable"; - return false; - } - } } if (call->Type()->Is()) { @@ -2892,6 +2927,30 @@ bool Validator::Structure(const sem::Struct* str, ast::PipelineStage stage) cons } return true; }, + [&](const ast::StructMemberAlignAttribute* align_attr) { + // From align attribute in WGSL spec: + // If align(n) is applied to a member of S with type T, and S can be the store + // type for a variable in address space AS, where AS is not uniform, then n must + // satisfy: n = k * RequiredAlignOf(T, AS), for some positive k + // + // Since it can only be put on a struct, we can limit the check to + // host-shareable and/or constructible types. Host-shareable catches anything + // instantiable in storage, constructible catches everything else (workgroup, + // function, private, immediate). + // + // RequiredAlignOf == AlignOf for applicable address spaces. + if (str->IsHostShareable() || str->IsConstructible()) { + auto align = + sem_.GetVal(align_attr->expr)->ConstantValue()->ValueAs(); + if (align % member->Type()->Align() != 0) { + AddError(align_attr->expr->source) + << "alignment must be a multiple of " + << style::Literal(member->Type()->Align()) << " bytes"; + return false; + } + } + return true; + }, [&](Default) { return true; }); if (!ok) { return false; @@ -3551,6 +3610,67 @@ bool Validator::CheckNoMultipleModuleScopeVarsOfAddressSpace(sem::Function* entr return true; } +bool Validator::CheckSubgroupMatrixOpOffset(const sem::BuiltinFn* fn, + const sem::ValueExpression* p_arg, + const sem::ValueExpression* offset_arg) const { + auto* ptr_ty = p_arg->Type()->As(); + if (!ptr_ty) { + return true; + } + auto* arr_ty = ptr_ty->StoreType()->As(); + if (!arr_ty) { + return true; + } + auto const_count = arr_ty->ConstantCount(); + if (!const_count) { + return true; + } + auto* offset_val = offset_arg->ConstantValue(); + if (!offset_val) { + return true; + } + + const core::type::SubgroupMatrix* mat_ty = nullptr; + if (fn->Fn() == wgsl::BuiltinFn::kSubgroupMatrixLoad) { + mat_ty = fn->ReturnType()->As(); + } else if (fn->Fn() == wgsl::BuiltinFn::kSubgroupMatrixStore) { + mat_ty = fn->Parameters()[2]->Type()->As(); + } + if (!mat_ty) { + return true; + } + + auto arr_elem_size = arr_ty->ElemType()->Size(); + auto mat_comp_size = mat_ty->Type()->Size(); + if (mat_comp_size == 0) { + return true; + } + + auto limit = (const_count.value() * arr_elem_size) / mat_comp_size; + + uint32_t offset = 0; + if (offset_arg->Type()->IsUnsignedIntegerScalar()) { + offset = offset_val->ValueAs(); + } else if (offset_arg->Type()->IsSignedIntegerScalar()) { + int32_t ival = offset_val->ValueAs(); + if (ival < 0) { + AddError(offset_arg->Declaration()->source) + << "the offset argument of " << fn->str() << " must be non-negative"; + return false; + } + offset = static_cast(ival); + } + + if (offset >= limit) { + AddError(offset_arg->Declaration()->source) + << "the offset argument of " << fn->str() << " (" << offset + << ") is out of bounds of the array type of size " << limit; + return false; + } + + return true; +} + bool Validator::SwizzleAssignment(const sem::Swizzle* lhs, const Source& source) const { // Check whether swizzle components are duplicated. while (lhs) { diff --git a/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.h b/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.h index 2fda394d3..e7b8a050b 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/resolver/validator.h @@ -56,6 +56,7 @@ class Variable; namespace tint::sem { class Array; class BreakIfStatement; +class BuiltinFn; class Call; class ForLoopStatement; class IfStatement; @@ -545,7 +546,7 @@ class Validator { /// @returns true on success, false otherwise bool QuadBroadcast(const sem::Call* call) const; - /// Validates a bufferView builtin function + /// Validates a bufferView or bufferArrayView builtin function /// @param call the builtin call to validate /// @returns true on success, false otherwise bool BufferView(const sem::Call* call) const; @@ -652,6 +653,15 @@ class Validator { bool CheckNoMultipleModuleScopeVarsOfAddressSpace(sem::Function* entry_point, core::AddressSpace space) const; + /// Validates the offset argument of a subgroupMatrixLoad or subgroupMatrixStore call. + /// @param fn the builtin function symbol + /// @param p_arg the pointer argument + /// @param offset_arg the offset argument + /// @returns true on success, false if an error was raised. + bool CheckSubgroupMatrixOpOffset(const sem::BuiltinFn* fn, + const sem::ValueExpression* p_arg, + const sem::ValueExpression* offset_arg) const; + SymbolTable& symbols_; diag::List& diagnostics_; SemHelper& sem_; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_enum_expression.cc b/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_enum_expression.cc index b98a7e685..dd25ce3b1 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_enum_expression.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_enum_expression.cc @@ -38,9 +38,8 @@ TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); +TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); -TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); -TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); TINT_INSTANTIATE_TYPEINFO(tint::sem::BuiltinEnumExpression); namespace tint::sem { diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.cc b/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.cc index 1242ab6d5..635127bd8 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.cc @@ -102,12 +102,6 @@ bool BuiltinFn::IsResourceTable() const { } wgsl::LanguageFeature BuiltinFn::RequiredLanguageFeature() const { - if (fn_ == wgsl::BuiltinFn::kTextureBarrier) { - return wgsl::LanguageFeature::kReadonlyAndReadwriteStorageTextures; - } - if (IsPacked4x8IntegerDotProductBuiltin()) { - return wgsl::LanguageFeature::kPacked4X8IntegerDotProduct; - } if (IsTexelBuffer()) { return wgsl::LanguageFeature::kTexelBuffers; } diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.h b/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.h index 566b27956..8c9f8eaaf 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/builtin_fn.h @@ -103,7 +103,8 @@ class BuiltinFn final : public Castable { bool IsResourceTable() const; /// @returns the required language feature of this builtin function. Returns - /// wgsl::LanguageFeature::kUndefined if no language feature is required. + /// wgsl::LanguageFeature::kUndefined if no language feature is required, or if the language + /// feature has been fully shipped. wgsl::LanguageFeature RequiredLanguageFeature() const; /// @returns the builtin table overload info diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/function.h b/3rdparty/dawn/src/tint/lang/wgsl/sem/function.h index 11b44b907..c43f6386a 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/function.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/function.h @@ -28,12 +28,14 @@ #ifndef SRC_TINT_LANG_WGSL_SEM_FUNCTION_H_ #define SRC_TINT_LANG_WGSL_SEM_FUNCTION_H_ +#include #include #include #include #include "src/tint/lang/wgsl/enums.h" #include "src/tint/lang/wgsl/sem/call.h" +#include "src/tint/utils/containers/hashmap.h" #include "src/tint/utils/containers/unique_vector.h" #include "src/tint/utils/containers/vector.h" #include "src/tint/utils/symbol/symbol.h" @@ -221,6 +223,29 @@ class Function final : public Castable { return diagnostic_severities_; } + /// Adds `var` as a transitively referenced unsized buffer with required size `size`. + /// If `var` is already transitively referenced, the maximum size is kept. + /// @param var the unsized buffer + /// @param size the required binding size + void AddTransitivelyReferencedUnsizedBufferSize(const GlobalVariable* var, uint64_t size) { + auto where = transitively_referenced_unsized_buffer_sizes_.Get(var); + if (where) { + *where = std::max(*where, size); + } else { + transitively_referenced_unsized_buffer_sizes_.Add(var, size); + } + } + + /// @return The required size for the unsized buffer `var`. std::nullopt if it is unreferenced. + std::optional TransitivelyReferencedUnsizedBufferSize( + const GlobalVariable* var) const { + auto where = transitively_referenced_unsized_buffer_sizes_.Get(var); + if (where) { + return *where; + } + return std::nullopt; + } + private: Function(const Function&) = delete; Function(Function&&) = delete; @@ -241,6 +266,7 @@ class Function final : public Castable { wgsl::DiagnosticRuleSeverities diagnostic_severities_; std::optional directly_used_subgroup_matrix_ = std::nullopt; + Hashmap transitively_referenced_unsized_buffer_sizes_; std::optional return_location_; }; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.cc b/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.cc index d3b3478e8..dfa1dd773 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.cc @@ -60,4 +60,24 @@ Swizzle::Swizzle(const ast::MemberAccessorExpression* declaration, Swizzle::~Swizzle() = default; +CollapsedSwizzle CollapseLhsSwizzle(const Swizzle* swizzle) { + // Initialize with the outermost swizzle object and indices. + CollapsedSwizzle res{ + .vector = swizzle->Object(), + .indices = swizzle->Indices(), + }; + // If the inner object is also a swizzle, collapse it down. + while (auto* inner_swizzle = res.vector->As()) { + tint::Vector combined; + // For each index in the outer swizzle, get the corresponding index into the inner + // swizzle. + for (uint32_t i : res.indices) { + combined.Push(inner_swizzle->Indices()[i]); + } + res.indices = std::move(combined); + res.vector = inner_swizzle->Object(); + } + return res; +} + } // namespace tint::sem diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.h b/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.h index bb6c423a4..7d575d90a 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/member_accessor_expression.h @@ -102,6 +102,25 @@ class Swizzle final : public Castable { tint::Vector const indices_; }; +/// Holds the base vector and collapsed indices of a potentially chained swizzle. +struct CollapsedSwizzle { + /// The base vector expression + const ValueExpression* vector = nullptr; + /// The collapsed swizzle indices + tint::Vector indices; +}; + +/// Collapse a possibly nested chain of swizzles on the lhs of an assignment into a single set of +/// swizzle indices on the base vector. +/// +/// Note that target components cannot be repeated in lhs swizzles used for assignment, +/// so each consecutive swizzle on a vector will produce a smaller or equal sized vector (i.e. +/// v.xyzw.xy.yx.x). +/// +/// @param swizzle the outermost swizzle node +/// @returns the collapsed swizzle +CollapsedSwizzle CollapseLhsSwizzle(const Swizzle* swizzle); + } // namespace tint::sem #endif // SRC_TINT_LANG_WGSL_SEM_MEMBER_ACCESSOR_EXPRESSION_H_ diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/sampler_texture_pair.h b/3rdparty/dawn/src/tint/lang/wgsl/sem/sampler_texture_pair.h index beee4f0c6..85a03c462 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/sampler_texture_pair.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/sampler_texture_pair.h @@ -31,7 +31,7 @@ #include #include "src/tint/api/common/binding_point.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint::sem { diff --git a/3rdparty/dawn/src/tint/lang/wgsl/sem/variable.h b/3rdparty/dawn/src/tint/lang/wgsl/sem/variable.h index 78b9f4267..4038bf972 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/sem/variable.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/sem/variable.h @@ -134,16 +134,8 @@ class LocalVariable final : public Castable { /// @returns the statement that declares this local variable const sem::Statement* Statement() const { return statement_; } - /// Sets the Type, Function or Variable that this local variable shadows - /// @param shadows the Type, Function or Variable that this variable shadows - void SetShadows(const CastableBase* shadows) { shadows_ = shadows; } - - /// @returns the Type, Function or Variable that this local variable shadows - const CastableBase* Shadows() const { return shadows_; } - private: const sem::Statement* const statement_; - const CastableBase* shadows_ = nullptr; }; /// Attributes that can be applied to global variables @@ -230,13 +222,6 @@ class Parameter final : public Castable { /// @returns the CallTarget owner of this parameter const CallTarget* Owner() const { return owner_; } - /// Sets the Type, Function or Variable that this local variable shadows - /// @param shadows the Type, Function or Variable that this variable shadows - void SetShadows(const CastableBase* shadows) { shadows_ = shadows; } - - /// @returns the Type, Function or Variable that this local variable shadows - const CastableBase* Shadows() const { return shadows_; } - /// @return the mutable attributes for the parameter ParameterAttributes& Attributes() { return attributes_; } @@ -247,7 +232,6 @@ class Parameter final : public Castable { const uint32_t index_ = 0; core::ParameterUsage usage_ = core::ParameterUsage::kNone; CallTarget const* owner_ = nullptr; - const CastableBase* shadows_ = nullptr; ParameterAttributes attributes_; }; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/writer/common/options.h b/3rdparty/dawn/src/tint/lang/wgsl/writer/common/options.h index 3d54f3743..b38e2ac33 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/writer/common/options.h +++ b/3rdparty/dawn/src/tint/lang/wgsl/writer/common/options.h @@ -29,7 +29,7 @@ #define SRC_TINT_LANG_WGSL_WRITER_COMMON_OPTIONS_H_ #include "src/tint/lang/wgsl/allowed_features.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" namespace tint::wgsl::writer { diff --git a/3rdparty/dawn/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc b/3rdparty/dawn/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc index b225235e4..b004ac69c 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc @@ -36,7 +36,6 @@ #include "src/tint/lang/core/fluent_types.h" #include "src/tint/lang/core/ir/access.h" #include "src/tint/lang/core/ir/binary.h" -#include "src/tint/lang/core/ir/bitcast.h" #include "src/tint/lang/core/ir/block.h" #include "src/tint/lang/core/ir/break_if.h" #include "src/tint/lang/core/ir/call.h" @@ -44,6 +43,7 @@ #include "src/tint/lang/core/ir/construct.h" #include "src/tint/lang/core/ir/continue.h" #include "src/tint/lang/core/ir/convert.h" +#include "src/tint/lang/core/ir/core_builtin_call.h" #include "src/tint/lang/core/ir/discard.h" #include "src/tint/lang/core/ir/exit_if.h" #include "src/tint/lang/core/ir/exit_loop.h" @@ -102,13 +102,7 @@ class State { explicit State(const core::ir::Module& m) : mod(m) {} Program Run(const Options& options) { - core::ir::Capabilities caps{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPhonyInstructions, - core::ir::Capability::kAllowRefTypes, - }; - if (auto res = ValidateBeforeIfNeeded(mod, caps, "wgsl.to_program"); res != Success) { + if (auto res = Validate(mod, "before wgsl.to_program"); res != Success) { // IR module failed validation. b.Diagnostics().AddError(Source{}) << res.Failure(); return Program{resolver::Resolve(b)}; @@ -131,16 +125,19 @@ class State { if (options.allow_non_uniform_derivatives) { // Suppress errors regarding non-uniform derivative operations if requested, by adding a // diagnostic directive to the module. - b.DiagnosticDirective(wgsl::DiagnosticSeverity::kOff, "derivative_uniformity"); + b.DiagnosticDirective(wgsl::DiagnosticSeverity::kOff, + b.DiagnosticRuleName("derivative_uniformity")); } if (options.allow_non_uniform_subgroup_operations) { // Suppress errors regarding non-uniform subgroups operations if requested, by adding a // diagnostic directive to the module. - b.DiagnosticDirective(wgsl::DiagnosticSeverity::kOff, "subgroup_uniformity"); + b.DiagnosticDirective(wgsl::DiagnosticSeverity::kOff, + b.DiagnosticRuleName("subgroup_uniformity")); } if (options.disable_unreachable_code_warning) { // Suppress warnings regarding unreachable code - b.DiagnosticDirective(wgsl::DiagnosticSeverity::kOff, "chromium", "unreachable_code"); + b.DiagnosticDirective(wgsl::DiagnosticSeverity::kOff, + b.DiagnosticRuleName("chromium", "unreachable_code")); } return Program{resolver::Resolve(b, options.allowed_features)}; @@ -199,10 +196,7 @@ class State { [&](const core::ir::Override* override_) { Override(override_); }, // [&](const core::ir::Binary* binary) { Binary(binary); }, // [&](const core::ir::Unary* unary) { Unary(unary); }, // - [&](const core::ir::Bitcast* c) { - auto ty = Type(c->Result()->Type()); - Bind(c->Result(), b.Bitcast(ty, Expr(c->Args()[0]))); - }, + [&](const wgsl::ir::BuiltinCall* c) { Call(c); }, // TINT_ICE_ON_NO_MATCH); } } @@ -589,7 +583,7 @@ class State { void BreakIf(const core::ir::BreakIf* i) { Append(b.BreakIf(Expr(i->Condition()))); } void Return(const core::ir::Return* ret) { - if (ret->Args().IsEmpty()) { + if (ret->Args().empty()) { // Return has no arguments. // If this block is nested withing some control flow, then we must // emit a 'return' statement, otherwise we've just naturally reached @@ -601,11 +595,11 @@ class State { } // Return has arguments - this is the return value. - if (ret->Args().Length() != 1) { - TINT_IR_ICE(mod) << "expected 1 value for return, got " << ret->Args().Length(); + if (ret->Args().size() != 1) { + TINT_IR_ICE(mod) << "expected 1 value for return, got " << ret->Args().size(); } - Append(b.Return(Expr(ret->Args().Front()))); + Append(b.Return(Expr(ret->Args().front()))); } void Var(const core::ir::Var* var) { @@ -743,8 +737,16 @@ class State { const ast::CallExpression* expr = nullptr; if (!c->ExplicitTemplateParams().IsEmpty()) { Vector tmpl_args; - for (auto* e : c->ExplicitTemplateParams()) { - tmpl_args.Push(Type(e).expr); + for (auto& e : c->ExplicitTemplateParams()) { + if (std::holds_alternative(e)) { + tmpl_args.Push(Type(std::get(e)).expr); + } else if (std::holds_alternative(e)) { + StringStream str; + str << std::get(e); + tmpl_args.Push(b.Expr(str.str())); + } else { + TINT_UNREACHABLE() << "Unhandled template parameter kind"; + } } expr = b.Call(b.Ident(c->Func(), std::move(tmpl_args)), std::move(args)); } else { @@ -765,10 +767,6 @@ class State { auto ty = Type(c->Result()->Type()); Bind(c->Result(), b.Call(ty, std::move(args))); }, - [&](const core::ir::Bitcast* c) { - auto ty = Type(c->Result()->Type()); - Bind(c->Result(), b.Bitcast(ty, args[0])); - }, [&](const core::ir::Discard*) { Append(b.Discard()); }, // TINT_ICE_ON_NO_MATCH); } diff --git a/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/ptr_to_ref.cc b/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/ptr_to_ref.cc index faa11b60d..8665bf9b5 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/ptr_to_ref.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/ptr_to_ref.cc @@ -139,17 +139,12 @@ struct Impl { } // namespace Result PtrToRef(core::ir::Module& mod) { - TINT_CHECK_RESULT( - core::ir::ValidateBeforeIfNeeded(mod, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - core::ir::Capability::kAllowPhonyInstructions, - }, - "wgsl.PtrToRef")); + core::ir::AssertValid(mod, "before wgsl.PtrToRef"); Impl{mod}.Run(); + mod.properties.Add(core::ir::Property::kAllowRefTypes); + return Success; } diff --git a/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/raise.cc b/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/raise.cc index a247e5d8a..a5fbf66d3 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/raise.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/raise.cc @@ -61,6 +61,7 @@ wgsl::BuiltinFn Convert(core::BuiltinFn fn) { CASE(kAtan) CASE(kAtan2) CASE(kAtanh) + CASE(kBitcast) CASE(kCeil) CASE(kClamp) CASE(kCos) @@ -209,6 +210,8 @@ wgsl::BuiltinFn Convert(core::BuiltinFn fn) { CASE(kGetResource) CASE(kBufferView) CASE(kBufferLength) + CASE(kBufferArrayView) + case core::BuiltinFn::kAddSat: // lowered below case core::BuiltinFn::kNone: break; } @@ -220,7 +223,7 @@ void ReplaceBuiltinFnCall(core::ir::Builder& b, core::ir::CoreBuiltinCall* call) auto* replacement = b.CallWithResult( call->DetachResult(), Convert(call->Func()), std::move(args)); if (!call->ExplicitTemplateParams().IsEmpty()) { - Vector tmpl_args; + Vector tmpl_args; for (auto p : call->ExplicitTemplateParams()) { tmpl_args.Push(p); } @@ -264,6 +267,19 @@ void ReplaceWorkgroupBarrier(core::ir::Builder& b, core::ir::CoreBuiltinCall* ca load->Destroy(); } +void ReplaceAddSat(core::ir::Builder& b, core::ir::CoreBuiltinCall* call) { + auto* lhs = call->Args()[0]; + auto* rhs = call->Args()[1]; + b.InsertBefore(call, [&] { + auto* add = b.Add(lhs, rhs); + auto* lt = b.LessThan(add, lhs); + auto* splat = b.Splat(call->Result()->Type(), b.Constant(core::u32(0xffffffff))); + b.CallWithResult(call->DetachResult(), wgsl::BuiltinFn::kSelect, add, + splat, lt); + }); + call->Destroy(); +} + } // namespace Result Raise(core::ir::Module& mod) { @@ -279,6 +295,9 @@ Result Raise(core::ir::Module& mod) { case core::BuiltinFn::kWorkgroupBarrier: ReplaceWorkgroupBarrier(b, call); break; + case core::BuiltinFn::kAddSat: + ReplaceAddSat(b, call); + break; default: ReplaceBuiltinFnCall(b, call); break; diff --git a/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/value_to_let.cc b/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/value_to_let.cc index 93702a47d..0f0a22983 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/value_to_let.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/writer/raise/value_to_let.cc @@ -178,6 +178,7 @@ struct State { } if (!value->IsUsed() && !ir.NameOf(value).IsValid()) { + ir.properties.Add(core::ir::Property::kAllowPhonyInstructions); auto* phony = b.Phony(value); phony->InsertAfter(inst); return; @@ -197,13 +198,7 @@ struct State { } // namespace Result ValueToLet(core::ir::Module& ir) { - TINT_CHECK_RESULT( - core::ir::ValidateBeforeIfNeeded(ir, - core::ir::Capabilities{ - core::ir::Capability::kAllowMultipleEntryPoints, - core::ir::Capability::kAllowOverrides, - }, - "wgsl.ValueToLet")); + core::ir::AssertValid(ir, "before wgsl.ValueToLet"); State{ir}.Process(); diff --git a/3rdparty/dawn/src/tint/lang/wgsl/writer/writer.cc b/3rdparty/dawn/src/tint/lang/wgsl/writer/writer.cc index 3716326f0..901d9494d 100644 --- a/3rdparty/dawn/src/tint/lang/wgsl/writer/writer.cc +++ b/3rdparty/dawn/src/tint/lang/wgsl/writer/writer.cc @@ -29,6 +29,7 @@ #include +#include "src/tint/lang/core/ir/validator.h" #include "src/tint/lang/wgsl/program/program.h" #include "src/tint/lang/wgsl/writer/ast_printer/ast_printer.h" #include "src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.h" @@ -56,6 +57,13 @@ Result WgslFromIR(core::ir::Module& module, const Options& options) { } Result ProgramFromIR(core::ir::Module& module, const Options& options) { + const core::ir::Properties kUnsupportedProperties{ + core::ir::Property::kAllow8BitIntegers, + core::ir::Property::kAllowNonCoreTypes, + core::ir::Property::kAllowUnannotatedModuleIOVariables, + }; + AssertNoUnsupportedProperties(module, kUnsupportedProperties); + // core-dialect -> WGSL-dialect TINT_CHECK_RESULT(Raise(module)); diff --git a/3rdparty/dawn/src/tint/tint.natvis b/3rdparty/dawn/src/tint/tint.natvis index b5fb5f359..5bd882ee3 100644 --- a/3rdparty/dawn/src/tint/tint.natvis +++ b/3rdparty/dawn/src/tint/tint.natvis @@ -34,14 +34,12 @@ - - {{ length={len}, capacity={cap} }} + + {{ length={len}, capacity={buffer._Mysize} }} - len - data + buffer._Myptr @@ -49,12 +47,10 @@ - impl_.slice.cap > (int)$T2 - - + impl_.slice.buffer._Mysize > (size_t)$T2 Length() - impl_.slice.data + impl_.slice.buffer._Myptr @@ -63,7 +59,6 @@ can_move_ slice_ - diff --git a/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.cc b/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.cc index 5c790dd59..3c41de63a 100644 --- a/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.cc +++ b/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.cc @@ -30,24 +30,21 @@ #include #include "src/tint/utils/macros/compiler.h" +#include "src/tint/utils/memory/copy.h" namespace tint::bytes { BufferReader::~BufferReader() = default; -// TODO(408010433): Rewrite internals using span to avoid UBU during read -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); size_t BufferReader::Read(std::byte* out, size_t count) { - size_t n = std::min(count, bytes_remaining_); - memcpy(out, data_, n); - data_ += n; - bytes_remaining_ -= n; + size_t n = std::min(count, data_.size()); + tint::Copy(out, count, data_.first(n)); + data_ = data_.subspan(n); return n; } -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); bool BufferReader::IsEOF() const { - return bytes_remaining_ == 0; + return data_.empty(); } } // namespace tint::bytes diff --git a/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.h b/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.h index f75c7f692..b8ee4f539 100644 --- a/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.h +++ b/3rdparty/dawn/src/tint/utils/bytes/buffer_reader.h @@ -40,25 +40,27 @@ namespace tint::bytes { /// BufferReader is an implementation of the Reader interface backed by a buffer. class BufferReader final : public Reader { public: - // Destructor + /// Destructor ~BufferReader() override; + // This constructor represents the boundary between unsafe and safe memory constructs, since a + // raw pointer is being converted to a std::span. There is no way to avoid this warning, because + // if the compiler could statically guarantee the raw pointer + size was valid here, there would + // be no need for std::span to exist. + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// Constructor /// @param data the data to read from /// @param size the number of bytes in the buffer - BufferReader(const std::byte* data, size_t size) : data_(data), bytes_remaining_(size) { - TINT_ASSERT(data); - } + BufferReader(const std::byte* data, size_t size) : data_(data, size) { TINT_ASSERT(data); } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// Constructor /// @param str the string to read from - explicit BufferReader(std::string_view str) - : data_(reinterpret_cast(str.data())), bytes_remaining_(str.length()) {} + explicit BufferReader(std::string_view str) : data_(std::as_bytes(std::span{str})) {} /// Constructor /// @param span the byte span to read from - explicit BufferReader(std::span span) - : data_(span.data()), bytes_remaining_(span.size()) { + explicit BufferReader(std::span span) : data_(span) { TINT_ASSERT(span.data()); } @@ -70,10 +72,7 @@ class BufferReader final : public Reader { private: /// The data to read from - const std::byte* data_ = nullptr; - - /// The number of bytes remaining - size_t bytes_remaining_ = 0; + std::span data_; }; } // namespace tint::bytes diff --git a/3rdparty/dawn/src/tint/utils/bytes/decoder.h b/3rdparty/dawn/src/tint/utils/bytes/decoder.h index 7e11538fe..7fb820ae8 100644 --- a/3rdparty/dawn/src/tint/utils/bytes/decoder.h +++ b/3rdparty/dawn/src/tint/utils/bytes/decoder.h @@ -39,7 +39,7 @@ #include #include "src/tint/utils/bytes/reader.h" -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/result.h" namespace tint::bytes { @@ -58,19 +58,21 @@ Result Decode(Reader& reader, ARGS&&... args) { /// Decoder specialization for integer types template -struct Decoder>> { + requires(std::is_integral_v) +struct Decoder { /// Decode decodes the integer type from @p reader. /// @param reader the reader to decode from /// @param endianness the endianness of the integer /// @returns the decoded integer type, or an error if the stream is too short. - static Result Decode(Reader& reader, Endianness endianness = Endianness::kLittle) { + static Result Decode(Reader& reader, std::endian endianness = std::endian::little) { return reader.Int(endianness); } }; /// Decoder specialization for floating point types template -struct Decoder>> { + requires(std::is_floating_point_v) +struct Decoder { /// Decode decodes the floating point type from @p reader. /// @param reader the reader to decode from /// @returns the decoded floating point type, or an error if the stream is too short. @@ -255,7 +257,7 @@ struct Decoder::kMax)>> { /// @param reader the reader to decode from /// @param endianness the endianness of the enum /// @returns the decoded enum type, or an error if the stream is too short. - static Result Decode(Reader& reader, Endianness endianness = Endianness::kLittle) { + static Result Decode(Reader& reader, std::endian endianness = std::endian::little) { using Range = tint::EnumRange; using U = std::underlying_type_t; TINT_CHECK_RESULT_UNWRAP(value, reader.Int(endianness)); diff --git a/3rdparty/dawn/src/tint/utils/bytes/reader.h b/3rdparty/dawn/src/tint/utils/bytes/reader.h index 40a279f28..28b590bea 100644 --- a/3rdparty/dawn/src/tint/utils/bytes/reader.h +++ b/3rdparty/dawn/src/tint/utils/bytes/reader.h @@ -28,9 +28,9 @@ #ifndef SRC_TINT_UTILS_BYTES_READER_H_ #define SRC_TINT_UTILS_BYTES_READER_H_ +#include #include -#include "src/tint/utils/bytes/endianness.h" #include "src/tint/utils/bytes/swap.h" #include "src/tint/utils/result.h" @@ -60,13 +60,13 @@ class Reader { /// @param endianness the encoded endianness of the integer /// @return the deserialized integer template - Result Int(Endianness endianness = Endianness::kLittle) { + Result Int(std::endian endianness = std::endian::little) { static_assert(std::is_integral_v); T out = 0; if (size_t n = Read(reinterpret_cast(&out), sizeof(T)); n != sizeof(T)) { return Failure{"EOF"}; } - if (NativeEndianness() != endianness) { + if (std::endian::native != endianness) { out = Swap(out); } return out; diff --git a/3rdparty/dawn/src/tint/utils/bytes/swap.h b/3rdparty/dawn/src/tint/utils/bytes/swap.h index 632f72386..461d24aa5 100644 --- a/3rdparty/dawn/src/tint/utils/bytes/swap.h +++ b/3rdparty/dawn/src/tint/utils/bytes/swap.h @@ -28,34 +28,30 @@ #ifndef SRC_TINT_UTILS_BYTES_SWAP_H_ #define SRC_TINT_UTILS_BYTES_SWAP_H_ +#include +#include #include -#include #include #include #include "src/tint/utils/macros/compiler.h" +#include "src/tint/utils/memory/copy.h" namespace tint::bytes { /// @returns the input value with all bytes reversed /// @param value the input value, can be any type that passes std::is_integral /// (this includes non-obvious types like wchar_t) -/// TODO(394825124): Once ranges from C++20 is available this code can be -/// rewritten to avoid needing to disable warnings. -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); template [[nodiscard]] inline T Swap(T value) { static_assert(std::is_integral_v); - uint8_t bytes[sizeof(T)]; - memcpy(bytes, &value, sizeof(T)); - for (size_t i = 0; i < sizeof(T) / 2; i++) { - std::swap(bytes[i], bytes[sizeof(T) - i - 1]); - } + std::array bytes; + tint::Copy(std::span{bytes}, value); + std::ranges::reverse(bytes); T out; - memcpy(&out, bytes, sizeof(T)); + tint::Copy(&out, 1, std::span{bytes}); return out; } -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); } // namespace tint::bytes diff --git a/3rdparty/dawn/src/tint/utils/containers/hashmap_base.h b/3rdparty/dawn/src/tint/utils/containers/hashmap_base.h index d8d7c23a2..d7b45693e 100644 --- a/3rdparty/dawn/src/tint/utils/containers/hashmap_base.h +++ b/3rdparty/dawn/src/tint/utils/containers/hashmap_base.h @@ -29,6 +29,7 @@ #define SRC_TINT_UTILS_CONTAINERS_HASHMAP_BASE_H_ #include +#include #include #include #include diff --git a/3rdparty/dawn/src/tint/utils/containers/scope_stack.h b/3rdparty/dawn/src/tint/utils/containers/scope_stack.h index b98b0472a..3d0325915 100644 --- a/3rdparty/dawn/src/tint/utils/containers/scope_stack.h +++ b/3rdparty/dawn/src/tint/utils/containers/scope_stack.h @@ -1,4 +1,5 @@ -// Copyright 2020 The Dawn & Tint Authors // +// Copyright 2020 The Dawn & Tint Authors +// // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // diff --git a/3rdparty/dawn/src/tint/utils/containers/slice.h b/3rdparty/dawn/src/tint/utils/containers/slice.h deleted file mode 100644 index ea64ce3fe..000000000 --- a/3rdparty/dawn/src/tint/utils/containers/slice.h +++ /dev/null @@ -1,311 +0,0 @@ -// Copyright 2023 The Dawn & Tint Authors -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// 1. Redistributions of source code must retain the above copyright notice, this -// list of conditions and the following disclaimer. -// -// 2. Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the following disclaimer in the documentation -// and/or other materials provided with the distribution. -// -// 3. Neither the name of the copyright holder nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef SRC_TINT_UTILS_CONTAINERS_SLICE_H_ -#define SRC_TINT_UTILS_CONTAINERS_SLICE_H_ - -#include -#include -#include - -#include "src/tint/utils/ice/ice.h" -#include "src/tint/utils/memory/bitcast.h" -#include "src/tint/utils/rtti/castable.h" -#include "src/tint/utils/rtti/traits.h" - -// tint::Slice is a memory view into a contiguous range of memory, to allow safer access and avoid -// unneeded copies, similar to std::string_view. -// There are external implementations of this type of container, //base/container/span in Chromium -// and std::span in C++20. Unfortunately Abseil does not implement its own version of this, and Tint -// cannot currently use the other options. -// -// Because this class is fundamentally working with T* values to avoid copying, and using asserts -// for bounds checking, -Wunsafe-buffer-usage will always trigger in here, since the compiler cannot -// guarantee it is safe. -// -// TODO(408010433): Revisit once C++20 is available -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); - -namespace tint { - -/// A type used to indicate an empty array. -struct EmptyType {}; - -/// An instance of the EmptyType. -inline constexpr EmptyType Empty; - -/// Mode enumerator for ReinterpretSlice -enum class ReinterpretMode { - /// Only upcasts of pointers are permitted - kSafe, - /// Potentially unsafe downcasts of pointers are also permitted - kUnsafe, -}; - -namespace detail { - -template -static constexpr bool ConstRemoved = std::is_const_v && !std::is_const_v; - -/// Private implementation of tint::CanReinterpretSlice. -/// Specialized for the case of TO equal to FROM, which is the common case, and avoids inspection of -/// the base classes, which can be troublesome if the slice is of an incomplete type. -template -struct CanReinterpretSlice { - private: - using TO_EL = std::remove_pointer_t>; - using FROM_EL = std::remove_pointer_t>; - - public: - /// @see tint::CanReinterpretSlice - static constexpr bool value = - // const can only be applied, not removed - !ConstRemoved && - - // Both TO and FROM are the same type (ignoring const) - (std::is_same_v, std::remove_const_t> || - - // Both TO and FROM are pointers... - ((std::is_pointer_v && std::is_pointer_v) && - - // const can only be applied to element type, not removed - !ConstRemoved && - - // Either: - // * Both the pointer elements are of the same type (ignoring const) - // * Both the pointer elements are both Castable, and MODE is kUnsafe, or FROM is of, - // or - // derives from TO - (std::is_same_v, std::remove_const_t> || - (IsCastable && - (MODE == ReinterpretMode::kUnsafe || tint::traits::IsTypeOrDerived))))); -}; - -/// Specialization of 'CanReinterpretSlice' for when TO and FROM are equal types. -template -struct CanReinterpretSlice { - /// Always `true` as TO and FROM are the same type. - static constexpr bool value = true; -}; - -} // namespace detail - -/// Evaluates whether a `Slice` and be reinterpreted as a `Slice`. -/// Slices can be reinterpreted if: -/// * TO has the same or more 'constness' than FROM. -/// * And either: -/// * `FROM` and `TO` are pointers to the same type -/// * `FROM` and `TO` are pointers to CastableBase (or derived), and the pointee type of `TO` is of -/// the same type as, or is an ancestor of the pointee type of `FROM`. -template -static constexpr bool CanReinterpretSlice = - tint::detail::CanReinterpretSlice::value; - -/// A slice represents a contiguous array of elements of type T. -template -struct Slice { - /// Type of `T`. - using value_type = T; - - /// The pointer to the first element in the slice - T* data = nullptr; - - /// The total number of elements in the slice - size_t len = 0; - - /// The total capacity of the backing store for the slice - size_t cap = 0; - - /// Constructor - constexpr Slice() = default; - - /// Constructor - constexpr Slice(EmptyType) {} // NOLINT - - /// Copy constructor with covariance / const conversion - /// @param other the vector to copy - /// @see CanReinterpretSlice for rules about conversion - template >> - Slice(const Slice& other) { // NOLINT(runtime/explicit) - *this = other.template Reinterpret(); - } - - /// Constructor - /// @param d pointer to the first element in the slice - /// @param l total number of elements in the slice - /// @param c total capacity of the backing store for the slice - constexpr Slice(T* d, size_t l, size_t c) : data(d), len(l), cap(c) {} - - /// Constructor - /// @param d pointer to the first element in the slice - /// @param l total number of elements in the slice - constexpr Slice(T* d, size_t l) : data(d), len(l), cap(l) {} - - /// Constructor - /// @param elements c-array of elements - template - constexpr Slice(T (&elements)[N]) // NOLINT - : data(elements), len(N), cap(N) {} - - /// Constructor - /// @param array std::array of elements - template - constexpr Slice(std::array& array) // NOLINT - : data(array.data()), len(N), cap(N) {} - - /// Reinterprets this slice as `const Slice&` - /// @returns the reinterpreted slice - /// @see CanReinterpretSlice - template - const Slice& Reinterpret() const { - static_assert(CanReinterpretSlice); - return *Bitcast*>(this); - } - - /// Reinterprets this slice as `Slice&` - /// @returns the reinterpreted slice - /// @see CanReinterpretSlice - template - Slice& Reinterpret() { - static_assert(CanReinterpretSlice); - return *Bitcast*>(this); - } - - /// @return true if the slice length is zero - bool IsEmpty() const { return len == 0; } - - /// @return the length of the slice - size_t Length() const { return len; } - - /// Create a new slice that represents an offset into this slice - /// @param offset the number of elements to offset - /// @return the new slice - Slice Offset(size_t offset) const { - if (offset > len) { - offset = len; - } - return Slice(data + offset, len - offset, cap - offset); - } - - /// Create a new slice that represents a truncated version of this slice - /// @param length the new length - /// @return a new slice that is truncated to `length` elements - Slice Truncate(size_t length) const { - if (length > len) { - length = len; - } - return Slice(data, length, length); - } - - /// Index operator - /// @param i the element index. Must be less than `len`. - /// @returns a reference to the i'th element. - T& operator[](size_t i) { - TINT_ASSERT(i < Length()); - return data[i]; - } - - /// Index operator - /// @param i the element index. Must be less than `len`. - /// @returns a reference to the i'th element. - const T& operator[](size_t i) const { - TINT_ASSERT(i < Length()); - return data[i]; - } - - /// @returns a reference to the first element in the vector - T& Front() { - TINT_ASSERT(!IsEmpty()); - return data[0]; - } - - /// @returns a reference to the first element in the vector - const T& Front() const { - TINT_ASSERT(!IsEmpty()); - return data[0]; - } - - /// @returns a reference to the last element in the vector - T& Back() { - TINT_ASSERT(!IsEmpty()); - return data[len - 1]; - } - - /// @returns a reference to the last element in the vector - const T& Back() const { - TINT_ASSERT(!IsEmpty()); - return data[len - 1]; - } - - /// @returns a pointer to the first element in the vector - T* begin() { return data; } - - /// @returns a pointer to the first element in the vector - const T* begin() const { return data; } - - /// @returns a pointer to one past the last element in the vector - T* end() { return data + len; } - - /// @returns a pointer to one past the last element in the vector - const T* end() const { return data + len; } - - /// @returns a reverse iterator starting with the last element in the vector - auto rbegin() { return std::reverse_iterator(end()); } - - /// @returns a reverse iterator starting with the last element in the vector - auto rbegin() const { return std::reverse_iterator(end()); } - - /// @returns the end for a reverse iterator - auto rend() { return std::reverse_iterator(begin()); } - - /// @returns the end for a reverse iterator - auto rend() const { return std::reverse_iterator(begin()); } - - /// Equality operator. - /// @param other the other slice to compare against - /// @returns true if all fields of this slice are equal to the fields of @p other - bool operator==(const Slice& other) const { - return data == other.data && len == other.len && cap == other.cap; - } - - /// Inequality operator. - /// @param other the other slice to compare against - /// @returns false if any fields of this slice are not equal to the fields of @p other - bool operator!=(const Slice& other) const { return !(*this == other); } -}; - -/// Deduction guide for Slice from c-array -/// @param elements the input elements -template -Slice(T (&elements)[N]) -> Slice; - -} // namespace tint - -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); - -#endif // SRC_TINT_UTILS_CONTAINERS_SLICE_H_ diff --git a/3rdparty/dawn/src/tint/utils/containers/transform.h b/3rdparty/dawn/src/tint/utils/containers/transform.h index 6f934b5df..e7f7b1986 100644 --- a/3rdparty/dawn/src/tint/utils/containers/transform.h +++ b/3rdparty/dawn/src/tint/utils/containers/transform.h @@ -29,6 +29,7 @@ #define SRC_TINT_UTILS_CONTAINERS_TRANSFORM_H_ #include +#include #include #include #include @@ -100,31 +101,32 @@ auto Transform(const Vector& in, TRANSFORMER&& transform) return result; } -/// Transform performs an element-wise transformation of a slice. -/// @param in the input slice. +/// Transform performs an element-wise transformation of a span. +/// @param in the input span. /// @param transform the transformation function with signature: `OUT(IN)` /// @tparam N the small-array size of the returned Vector /// @returns a new vector with each element of the source vector transformed by `transform`. template -auto Transform(Slice in, TRANSFORMER&& transform) -> Vector { +auto Transform(std::span in, TRANSFORMER&& transform) -> Vector { Vector result; - result.Reserve(in.len); - for (size_t i = 0; i < in.len; ++i) { + result.Reserve(in.size()); + for (size_t i = 0; i < in.size(); ++i) { result.Push(transform(in[i])); } return result; } -/// Transform performs an element-wise transformation of a slice. -/// @param in the input slice. +/// Transform performs an element-wise transformation of a span. +/// @param in the input span. /// @param transform the transformation function with signature: `OUT(IN, size_t)` /// @tparam N the small-array size of the returned Vector /// @returns a new vector with each element of the source vector transformed by `transform`. template -auto Transform(Slice in, TRANSFORMER&& transform) -> Vector { +auto Transform(std::span in, TRANSFORMER&& transform) + -> Vector { Vector result; - result.Reserve(in.len); - for (size_t i = 0; i < in.len; ++i) { + result.Reserve(in.size()); + for (size_t i = 0; i < in.size(); ++i) { result.Push(transform(in[i], i)); } return result; @@ -137,7 +139,7 @@ auto Transform(Slice in, TRANSFORMER&& transform) -> Vector auto Transform(VectorRef in, TRANSFORMER&& transform) -> Vector { - return Transform(in.Slice(), std::forward(transform)); + return Transform(in.AsSpan(), std::forward(transform)); } /// Transform performs an element-wise transformation of a vector reference. @@ -148,7 +150,7 @@ auto Transform(VectorRef in, TRANSFORMER&& transform) -> Vector auto Transform(VectorRef in, TRANSFORMER&& transform) -> Vector { - return Transform(in.Slice(), std::forward(transform)); + return Transform(in.AsSpan(), std::forward(transform)); } /// TransformN performs an element-wise transformation of a vector, transforming and returning at diff --git a/3rdparty/dawn/src/tint/utils/containers/vector.h b/3rdparty/dawn/src/tint/utils/containers/vector.h index 24aace0e0..d33eefe42 100644 --- a/3rdparty/dawn/src/tint/utils/containers/vector.h +++ b/3rdparty/dawn/src/tint/utils/containers/vector.h @@ -39,20 +39,21 @@ #include #include -#include "src/tint/utils/containers/slice.h" #include "src/tint/utils/ice/ice.h" #include "src/tint/utils/macros/compiler.h" #include "src/tint/utils/math/hash.h" #include "src/tint/utils/memory/aligned_storage.h" #include "src/tint/utils/memory/bitcast.h" +#include "src/tint/utils/rtti/castable.h" +#include "src/tint/utils/rtti/traits.h" // This file implements a custom STL style container & iterator in a performant manner, using -// C-style data access. It is not unexpected that -Wunsafe-buffer-usage triggers in this code, since -// the type of dynamic access being used cannot be guaranteed to be safe via static analysis. +// C-style data access. It is not unexpected that -Wunsafe-buffer-usage (UBU triggers in this code, +// since the type of dynamic access being used cannot be guaranteed to be safe via static analysis. // Attempting to change this code in simple ways to quiet these errors either a) negatively affects // the performance by introducing unneeded copes, or b) uses typing shenanigans to work around the -// warning that other linters/analyses are unhappy with. -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +// warning that other linters/analyses are unhappy with. The suppression of this warning has been +// narrowed to the code that it is expected to occur in. #ifndef TINT_VECTOR_MUTATION_CHECKS_ENABLED #ifdef NDEBUG @@ -70,19 +71,110 @@ TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// Forward declarations namespace tint { -template +template class VectorRef; -} // namespace tint -namespace tint { +/// A type used to indicate an empty array. +struct EmptyType {}; +/// An instance of the EmptyType. +inline constexpr EmptyType Empty; + +/// Mode enumerator for ReinterpretSlice +enum class ReinterpretMode { + /// Only upcasts of pointers are permitted + kSafe, + /// Potentially unsafe downcasts of pointers are also permitted + kUnsafe, +}; + +namespace detail { + +template +static constexpr bool ConstRemoved = std::is_const_v && !std::is_const_v; + +/// Private implementation of tint::CanReinterpretSlice. +/// Specialized for the case of TO equal to FROM, which is the common case, and avoids inspection of +/// the base classes, which can be troublesome if the slice is of an incomplete type. +template +struct CanReinterpretSlice { + private: + using TO_EL = std::remove_pointer_t>; + using FROM_EL = std::remove_pointer_t>; + + public: + /// @see tint::CanReinterpretSlice + static constexpr bool value = + // const can only be applied, not removed + !ConstRemoved && + + // Both TO and FROM are the same type (ignoring const) + (std::is_same_v, std::remove_const_t> || + + // Both TO and FROM are pointers... + ((std::is_pointer_v && std::is_pointer_v) && + + // const can only be applied to element type, not removed + !ConstRemoved && + + // Either: + // * Both the pointer elements are of the same type (ignoring const) + // * Both the pointer elements are both Castable, and MODE is kUnsafe, or FROM is of, + // or + // derives from TO + (std::is_same_v, std::remove_const_t> || + (IsCastable && + (MODE == ReinterpretMode::kUnsafe || tint::traits::IsTypeOrDerived))))); +}; + +/// Specialization of 'CanReinterpretSlice' for when TO and FROM are equal types. +template +struct CanReinterpretSlice { + /// Always `true` as TO and FROM are the same type. + static constexpr bool value = true; +}; + +} // namespace detail + +/// Evaluates whether a `Slice` and be reinterpreted as a `Slice`. +/// Slices can be reinterpreted if: +/// * TO has the same or more 'constness' than FROM. +/// * And either: +/// * `FROM` and `TO` are pointers to the same type +/// * `FROM` and `TO` are pointers to CastableBase (or derived), and the pointee type of `TO` is of +/// the same type as, or is an ancestor of the pointee type of `FROM`. +template +static constexpr bool CanReinterpretSlice = + tint::detail::CanReinterpretSlice::value; + +namespace internal { + +/// Slice is a memory view into the backing memory for a Vector. +/// +/// buffer.data() is the entire memory associated with the Vector +/// buffer.size() is the size of this memory, so maximum number of elements that can be in the +/// Vector before it needs to grow, so the capacity +/// len is the number of elements of the allocation being used by the Vector, so the +/// length +template +struct Slice { + /// The backing memory for the vector (capacity) + std::span buffer = {}; + /// The number of elements currently accessible in the Vector + size_t len = 0; +}; + +} // namespace internal + +// VectorIterator intrinsically depends on pointer math, so will always cause UBU warnings +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// VectorIterator is a forward iterator of Vector elements. template class VectorIterator { public: /// The iterator trait using iterator_category = std::random_access_iterator_tag; - /// The type of an element that this iterator points to + /// The type of element that this iterator points to using value_type = T; /// The type of the difference of two iterators using difference_type = std::ptrdiff_t; @@ -178,7 +270,8 @@ class VectorIterator { } /// @return the element this iterator currently points at - operator T*() const { return ptr_; } + // NOLINTNEXTLINE(google-explicit-constructor) + operator T*() const { return ptr_; } // NOLINT(runtime/explicit) /// @return the element this iterator currently points at T& operator*() const { return *ptr_; } @@ -289,6 +382,7 @@ class VectorIterator { std::atomic* iterator_count_ = nullptr; #endif }; +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// @param out the stream to write to /// @param it the VectorIterator @@ -299,7 +393,7 @@ auto& operator<<(STREAM& out, const VectorIterator& it) { return out << *it; } -/// Vector is a small-object-optimized, dynamically-sized vector of contigious elements of type T. +/// Vector is a small-object-optimized, dynamically-sized vector of contiguous elements of type T. /// /// Vector will fit `N` elements internally before spilling to heap allocations. If `N` is greater /// than zero, the internal elements are stored in a 'small array' held internally by the Vector. @@ -338,6 +432,7 @@ class Vector { Vector() = default; /// Constructor + // NOLINTNEXTLINE(google-explicit-constructor) Vector(EmptyType) {} // NOLINT(runtime/explicit) /// Constructor @@ -345,7 +440,7 @@ class Vector { Vector(std::initializer_list elements) { Reserve(elements.size()); for (auto& el : elements) { - new (&impl_.slice.data[impl_.slice.len++]) T{el}; + new (&impl_.slice.buffer[impl_.slice.len++]) T{el}; } } @@ -360,66 +455,62 @@ class Vector { /// Copy constructor (differing N length) /// @param other the vector to copy template - Vector(const Vector& other) { + // NOLINTNEXTLINE(google-explicit-constructor) + Vector(const Vector& other) { // NOLINT(runtime/explicit) Copy(other.impl_.slice); } /// Move constructor (differing N length) /// @param other the vector to move template - Vector(Vector&& other) { + // NOLINTNEXTLINE(google-explicit-constructor) + Vector(Vector&& other) { // NOLINT(runtime/explicit) Move(std::move(other)); } /// Copy constructor with covariance / const conversion /// @param other the vector to copy /// @see CanReinterpretSlice for rules about conversion - template >> + template + requires(CanReinterpretSlice) + // NOLINTNEXTLINE(google-explicit-constructor) Vector(const Vector& other) { // NOLINT(runtime/explicit) - Copy(other.impl_.slice.template Reinterpret); + Copy(other.impl_.slice); } /// Move constructor with covariance / const conversion /// @param other the vector to move /// @see CanReinterpretSlice for rules about conversion - template >> + template + requires(CanReinterpretSlice) + // NOLINTNEXTLINE(google-explicit-constructor) Vector(Vector&& other) { // NOLINT(runtime/explicit) Move(std::move(other)); } /// Move constructor from a mutable vector reference /// @param other the vector reference to move + // NOLINTNEXTLINE(google-explicit-constructor) Vector(VectorRef&& other) { MoveOrCopy(std::move(other)); } // NOLINT(runtime/explicit) /// Copy constructor from an immutable vector reference /// @param other the vector reference to copy - Vector(const VectorRef& other) { Copy(other.slice_); } // NOLINT(runtime/explicit) + // NOLINTNEXTLINE(google-explicit-constructor) + Vector(const VectorRef& other) { Copy(*other.slice_); } // NOLINT(runtime/explicit) - /// Copy constructor from an immutable slice - /// @param other the slice to copy - Vector(const Slice& other) { // NOLINT(runtime/explicit) - Copy(other); + /// Copy constructor from a span + /// @param span the span to copy + // NOLINTNEXTLINE(google-explicit-constructor) + Vector(std::span span) { // NOLINT(runtime/explicit) + Copy(internal::Slice{span, span.size()}); } - /// Copy constructor from an immutable slice - /// @param other the slice to copy - /// @note This overload only exists to keep MSVC happy. The compiler should be able to match - /// `Slice`. - Vector(const Slice& other) { // NOLINT(runtime/explicit) - Copy(other); - } - - /// Copy constructor from an immutable slice - /// @param other the slice to copy + /// Copy constructor from a span + /// @param span the span to copy template - Vector(const Slice& other) { // NOLINT(runtime/explicit) - Copy(other); + // NOLINTNEXTLINE(google-explicit-constructor) + Vector(std::span span) { // NOLINT(runtime/explicit) + Copy(internal::Slice{span, span.size()}); } /// Destructor @@ -467,8 +558,8 @@ class Vector { /// @param other the vector reference to copy /// @returns this vector so calls can be chained Vector& operator=(const VectorRef& other) { - if (&other.slice_ != &impl_.slice) { - Copy(other.slice_); + if (other.slice_ != &impl_.slice) { + Copy(*other.slice_); } return *this; } @@ -477,62 +568,74 @@ class Vector { /// @param other the vector reference to copy /// @returns this vector so calls can be chained Vector& operator=(VectorRef&& other) { - if (&other.slice_ != &impl_.slice) { + if (other.slice_ != &impl_.slice) { MoveOrCopy(std::move(other)); } return *this; } - /// Assignment operator for Slice - /// @param other the slice to copy + /// Assignment operator for std::span + /// @param span the span to copy /// @returns this vector so calls can be chained - Vector& operator=(const Slice& other) { - Copy(other); + Vector& operator=(std::span span) { + Copy(internal::Slice{span, span.size()}); return *this; } /// Index operator /// @param i the element index. Must be less than `len`. /// @returns a reference to the i'th element. - T& operator[](size_t i) { return impl_.slice[i]; } + T& operator[](size_t i) { + TINT_ASSERT(i < Length()); + return impl_.slice.buffer[i]; + } /// Index operator /// @param i the element index. Must be less than `len`. /// @returns a reference to the i'th element. - const T& operator[](size_t i) const { return impl_.slice[i]; } + const T& operator[](size_t i) const { + TINT_ASSERT(i < Length()); + return impl_.slice.buffer[i]; + } /// @return the number of elements in the vector size_t Length() const { return impl_.slice.len; } /// @return the number of elements that the vector could hold before a heap allocation needs to /// be made - size_t Capacity() const { return impl_.slice.cap; } + size_t Capacity() const { return impl_.slice.buffer.size(); } + // Iterating the buffers to move + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// Reserves memory to hold at least `new_cap` elements /// @param new_cap the new vector capacity void Reserve(size_t new_cap) { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); - if (new_cap > impl_.slice.cap) { - auto* old_data = impl_.slice.data; + if (new_cap > impl_.slice.buffer.size()) { + auto* old_data = impl_.slice.buffer.data(); + size_t len = impl_.slice.len; impl_.Allocate(new_cap); - for (size_t i = 0; i < impl_.slice.len; i++) { - new (&impl_.slice.data[i]) T(std::move(old_data[i])); + for (size_t i = 0; i < len; i++) { + new (&impl_.slice.buffer[i]) T(std::move(old_data[i])); old_data[i].~T(); } + impl_.slice.len = len; impl_.Free(old_data); } } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// Resizes the vector to the given length, expanding capacity if necessary. /// New elements are zero-initialized /// @param new_len the new vector length void Resize(size_t new_len) { Reserve(new_len); - for (size_t i = impl_.slice.len; i > new_len; i--) { // Shrink - impl_.slice.data[i - 1].~T(); + size_t old_len = impl_.slice.len; + for (size_t i = old_len; i > new_len; i--) { // Shrink + impl_.slice.buffer[i - 1].~T(); } - for (size_t i = impl_.slice.len; i < new_len; i++) { // Grow - new (&impl_.slice.data[i]) T{}; + for (size_t i = old_len; i < new_len; i++) { // Grow + new (&impl_.slice.buffer[i]) T{}; } impl_.slice.len = new_len; } @@ -542,11 +645,12 @@ class Vector { /// @param value the value to copy into the new elements void Resize(size_t new_len, const T& value) { Reserve(new_len); - for (size_t i = impl_.slice.len; i > new_len; i--) { // Shrink - impl_.slice.data[i - 1].~T(); + size_t old_len = impl_.slice.len; + for (size_t i = old_len; i > new_len; i--) { // Shrink + impl_.slice.buffer[i - 1].~T(); } - for (size_t i = impl_.slice.len; i < new_len; i++) { // Grow - new (&impl_.slice.data[i]) T{value}; + for (size_t i = old_len; i < new_len; i++) { // Grow + new (&impl_.slice.buffer[i]) T{value}; } impl_.slice.len = new_len; } @@ -562,7 +666,7 @@ class Vector { void Clear() { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); for (size_t i = 0; i < impl_.slice.len; i++) { - impl_.slice.data[i].~T(); + impl_.slice.buffer[i].~T(); } impl_.slice.len = 0; } @@ -571,20 +675,20 @@ class Vector { /// @param el the element to copy to the vector. void Push(const T& el) { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); - if (impl_.slice.len >= impl_.slice.cap) { + if (impl_.slice.len >= impl_.slice.buffer.size()) { Grow(); } - new (&impl_.slice.data[impl_.slice.len++]) T(el); + new (&impl_.slice.buffer[impl_.slice.len++]) T(el); } /// Appends a new element to the vector. /// @param el the element to move to the vector. void Push(T&& el) { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); - if (impl_.slice.len >= impl_.slice.cap) { + if (impl_.slice.len >= impl_.slice.buffer.size()) { Grow(); } - new (&impl_.slice.data[impl_.slice.len++]) T(std::move(el)); + new (&impl_.slice.buffer[impl_.slice.len++]) T(std::move(el)); } /// Appends a new element to the vector. @@ -592,10 +696,10 @@ class Vector { template void Emplace(ARGS&&... args) { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); - if (impl_.slice.len >= impl_.slice.cap) { + if (impl_.slice.len >= impl_.slice.buffer.size()) { Grow(); } - new (&impl_.slice.data[impl_.slice.len++]) T{std::forward(args)...}; + new (&impl_.slice.buffer[impl_.slice.len++]) T{std::forward(args)...}; } /// Removes and returns the last element from the vector. @@ -603,7 +707,7 @@ class Vector { T Pop() { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); TINT_ASSERT(!IsEmpty()); - auto& el = impl_.slice.data[--impl_.slice.len]; + auto& el = impl_.slice.buffer[--impl_.slice.len]; auto val = std::move(el); el.~T(); return val; @@ -617,15 +721,13 @@ class Vector { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); TINT_ASSERT(before <= Length()); size_t n = Length(); - Resize(Length() + 1); + Resize(n + 1); // Shuffle for (size_t i = n; i > before; i--) { - auto& src = impl_.slice.data[i - 1]; - auto& dst = impl_.slice.data[i]; - dst = std::move(src); + impl_.slice.buffer[i] = std::move(impl_.slice.buffer[i - 1]); } // Insert - impl_.slice.data[before] = std::forward(element); + impl_.slice.buffer[before] = std::forward(element); } /// Removes @p count elements from the vector @@ -635,17 +737,16 @@ class Vector { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); TINT_ASSERT(start < Length()); TINT_ASSERT((start + count) <= Length()); + size_t len = impl_.slice.len; // Shuffle - for (size_t i = start + count; i < impl_.slice.len; i++) { - auto& src = impl_.slice.data[i]; - auto& dst = impl_.slice.data[i - count]; - dst = std::move(src); + for (size_t i = start + count; i < len; i++) { + impl_.slice.buffer[i - count] = std::move(impl_.slice.buffer[i]); } // Pop for (size_t i = 0; i < count; i++) { - auto& el = impl_.slice.data[--impl_.slice.len]; - el.~T(); + impl_.slice.buffer[--len].~T(); } + impl_.slice.len = len; } /// Removes all the elements from the vector that match the predicate function. @@ -654,14 +755,14 @@ class Vector { template void EraseIf(PREDICATE&& predicate) { TINT_VECTOR_MUTATION_CHECK_ASSERT(iterator_count_ == 0); + size_t len = impl_.slice.len; // Shuffle size_t num_removed = 0; - for (size_t i = 0; i < impl_.slice.len; i++) { - auto& el = impl_.slice.data[i]; + for (size_t i = 0; i < len; i++) { + auto& el = impl_.slice.buffer[i]; bool remove = predicate(const_cast(el)); if (num_removed > 0) { - auto& dst = impl_.slice.data[i - num_removed]; - dst = std::move(el); + impl_.slice.buffer[i - num_removed] = std::move(el); } if (remove) { num_removed++; @@ -669,9 +770,9 @@ class Vector { } // Pop for (size_t i = 0; i < num_removed; i++) { - auto& el = impl_.slice.data[--impl_.slice.len]; - el.~T(); + impl_.slice.buffer[--len].~T(); } + impl_.slice.len = len; } /// Sort sorts the vector in-place using the predicate function @p pred @@ -717,74 +818,106 @@ class Vector { bool IsEmpty() const { return impl_.slice.len == 0; } /// @returns a reference to the first element in the vector - T& Front() { return impl_.slice.Front(); } + T& Front() { + TINT_ASSERT(!IsEmpty()); + return impl_.slice.buffer.front(); + } /// @returns a reference to the first element in the vector - const T& Front() const { return impl_.slice.Front(); } + const T& Front() const { + TINT_ASSERT(!IsEmpty()); + return impl_.slice.buffer.front(); + } /// @returns a reference to the last element in the vector - T& Back() { return impl_.slice.Back(); } + T& Back() { + TINT_ASSERT(!IsEmpty()); + return impl_.slice.buffer[impl_.slice.len - 1]; + } /// @returns a reference to the last element in the vector - const T& Back() const { return impl_.slice.Back(); } + const T& Back() const { + TINT_ASSERT(!IsEmpty()); + return impl_.slice.buffer[impl_.slice.len - 1]; + } #if TINT_VECTOR_MUTATION_CHECKS_ENABLED /// @returns a forward iterator to the first element of the vector - iterator begin() { return iterator{impl_.slice.begin(), &iterator_count_}; } + iterator begin() { return iterator{impl_.slice.buffer.data(), &iterator_count_}; } /// @returns a forward iterator to the first element of the vector const const_iterator begin() const { - return const_iterator{impl_.slice.begin(), &iterator_count_}; + return const_iterator{impl_.slice.buffer.data(), &iterator_count_}; + } + + // STL end()/rbegin() is beyond the end of the span, so requires unsafe pointer math + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + /// @returns a forward iterator to one-pass the last element of the vector + iterator end() { + return iterator{impl_.slice.buffer.data() + impl_.slice.len, &iterator_count_}; } /// @returns a forward iterator to one-pass the last element of the vector - iterator end() { return iterator{impl_.slice.end(), &iterator_count_}; } - - /// @returns a forward iterator to one-pass the last element of the vector - const const_iterator end() const { return const_iterator{impl_.slice.end(), &iterator_count_}; } + const const_iterator end() const { + return const_iterator{impl_.slice.buffer.data() + impl_.slice.len, &iterator_count_}; + } /// @returns a reverse iterator to the last element of the vector - reverse_iterator rbegin() { return reverse_iterator{impl_.slice.end(), &iterator_count_} + 1; } + reverse_iterator rbegin() { + return reverse_iterator{impl_.slice.buffer.data() + impl_.slice.len, &iterator_count_} + 1; + } /// @returns a reverse iterator to the last element of the vector const const_reverse_iterator rbegin() const { - return const_reverse_iterator{impl_.slice.end(), &iterator_count_} + 1; + return const_reverse_iterator{impl_.slice.buffer.data() + impl_.slice.len, + &iterator_count_} + + 1; + } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + + /// @returns a reverse iterator to one element before the first element of the vector + reverse_iterator rend() { + return reverse_iterator{impl_.slice.buffer.data(), &iterator_count_} + 1; } - /// @returns a reverse iterator to one element before the first element of the vector - reverse_iterator rend() { return reverse_iterator{impl_.slice.begin(), &iterator_count_} + 1; } - /// @returns a reverse iterator to one element before the first element of the vector const const_reverse_iterator rend() const { - return const_reverse_iterator{impl_.slice.begin(), &iterator_count_} + 1; + return const_reverse_iterator{impl_.slice.buffer.data(), &iterator_count_} + 1; } #else /// @returns a forward iterator to the first element of the vector - iterator begin() { return iterator{impl_.slice.begin()}; } + iterator begin() { return iterator{impl_.slice.buffer.data()}; } /// @returns a forward iterator to the first element of the vector - const const_iterator begin() const { return const_iterator{impl_.slice.begin()}; } + const const_iterator begin() const { return const_iterator{impl_.slice.buffer.data()}; } + + // STL end()/rbegin() is beyond the end of the span, so requires unsafe pointer math + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + /// @returns a forward iterator to one-pass the last element of the vector + iterator end() { return iterator{impl_.slice.buffer.data() + impl_.slice.len}; } /// @returns a forward iterator to one-pass the last element of the vector - iterator end() { return iterator{impl_.slice.end()}; } - - /// @returns a forward iterator to one-pass the last element of the vector - const const_iterator end() const { return const_iterator{impl_.slice.end()}; } + const const_iterator end() const { + return const_iterator{impl_.slice.buffer.data() + impl_.slice.len}; + } /// @returns a reverse iterator to the last element of the vector - reverse_iterator rbegin() { return reverse_iterator{impl_.slice.end()} + 1; } + reverse_iterator rbegin() { + return reverse_iterator{impl_.slice.buffer.data() + impl_.slice.len} + 1; + } /// @returns a reverse iterator to the last element of the vector const const_reverse_iterator rbegin() const { - return const_reverse_iterator{impl_.slice.end()} + 1; + return const_reverse_iterator{impl_.slice.buffer.data() + impl_.slice.len} + 1; } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// @returns a reverse iterator to one element before the first element of the vector - reverse_iterator rend() { return reverse_iterator{impl_.slice.begin()} + 1; } + reverse_iterator rend() { return reverse_iterator{impl_.slice.buffer.data()} + 1; } /// @returns a reverse iterator to one element before the first element of the vector const const_reverse_iterator rend() const { - return const_reverse_iterator{impl_.slice.begin()} + 1; + return const_reverse_iterator{impl_.slice.buffer.data()} + 1; } #endif @@ -823,17 +956,11 @@ class Vector { return !(*this == other); } - /// @returns the internal slice of the vector - tint::Slice Slice() { return impl_.slice; } - - /// @returns the internal slice of the vector - tint::Slice Slice() const { return impl_.slice; } + /// @returns the internal data of the vector as a std::span + std::span AsSpan() { return impl_.slice.buffer.subspan(0, impl_.slice.len); } /// @returns the internal data of the vector as a std::span - std::span AsSpan() { return {impl_.slice.data, impl_.slice.len}; } - - /// @returns the internal data of the vector as a std::span - std::span AsSpan() const { return {impl_.slice.data, impl_.slice.len}; } + std::span AsSpan() const { return impl_.slice.buffer.subspan(0, impl_.slice.len); } private: /// Friend class (differing specializations of this class) @@ -844,87 +971,100 @@ class Vector { template friend class VectorRef; - /// Friend class - template - friend class VectorRef; - template void AppendVariadic(Ts&&... args) { - ((new (&impl_.slice.data[impl_.slice.len++]) T(std::forward(args))), ...); + ((new (&impl_.slice.buffer[impl_.slice.len++]) T(std::forward(args))), ...); } /// Expands the capacity of the vector - void Grow() { Reserve(std::max(impl_.slice.cap, static_cast(1)) * 2); } + void Grow() { Reserve(std::max(impl_.slice.buffer.size(), static_cast(1)) * 2); } /// Moves 'other' to this vector, if possible, otherwise performs a copy. void MoveOrCopy(VectorRef&& other) { if (other.can_move_) { - // Just steal the slice. + // Just steal the data. ClearAndFree(); - impl_.slice = other.slice_; - other.slice_ = {}; + impl_.slice = *other.slice_; + *other.slice_ = {}; } else { - Copy(other.slice_); + Copy(*other.slice_); } } /// Copies all the elements from `other` to this vector, replacing the content of this vector. /// @param other the slice to copy template - void Copy(const tint::Slice& other) { - if (impl_.slice.cap < other.len) { + void Copy(const internal::Slice& other) { + size_t other_len = other.len; + if (impl_.slice.buffer.size() < other_len) { ClearAndFree(); - impl_.Allocate(other.len); + impl_.Allocate(other_len); } else { Clear(); } - impl_.slice.len = other.len; - for (size_t i = 0; i < impl_.slice.len; i++) { - new (&impl_.slice.data[i]) T{other.data[i]}; + for (size_t i = 0; i < other_len; i++) { + new (&impl_.slice.buffer[i]) T{other.buffer[i]}; } + impl_.slice.len = other_len; } + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// Moves all the elements from `other` to this vector, replacing the content of this vector. /// @param other the vector to move template void Move(Vector&& other) { - auto& other_slice = other.impl_.slice; if constexpr (std::is_same_v) { - if (other.impl_.CanMove()) { - // Just steal the slice. + auto& other_impl = other.impl_; + if (other_impl.CanMove()) { + // Just steal the data. ClearAndFree(); - impl_.slice = other_slice; - other_slice = {}; + impl_.slice = other_impl.slice; + other_impl.slice = {}; + if constexpr (N2 > 0) { + other_impl.slice.buffer = {&other_impl.small_arr[0].Get(), N2}; + } return; } } - // Can't steal the slice, so we have to move the elements instead. + // Can't steal the data, so we have to move the elements instead. + size_t other_len = other.Length(); // Ensure we have capacity for all the elements - if (impl_.slice.cap < other_slice.len) { + if (Capacity() < other_len) { ClearAndFree(); - impl_.Allocate(other_slice.len); + impl_.Allocate(other_len); } else { Clear(); } // Move each of the elements. - impl_.slice.len = other_slice.len; - for (size_t i = 0; i < impl_.slice.len; i++) { - new (&impl_.slice.data[i]) T{std::move(other_slice.data[i])}; + for (size_t i = 0; i < other_len; i++) { + new (&impl_.slice.buffer[i]) T{std::move(other[i])}; } + impl_.slice.len = other_len; // Clear other other.Clear(); } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); - /// Clears the vector, then frees the slice data. + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + /// Clears the vector, then frees the data. void ClearAndFree() { Clear(); - impl_.Free(impl_.slice.data); + impl_.Free(impl_.slice.buffer.data()); + if constexpr (N > 0) { + impl_.slice.buffer = {&impl_.small_arr[0].Get(), N}; + } else { + impl_.slice.buffer = {}; + } + impl_.slice.len = 0; } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// True if this vector uses a small array for small object optimization. constexpr static bool HasSmallArray = N > 0; @@ -932,52 +1072,59 @@ class Vector { /// A structure that has the same size and alignment as T. using TStorage = AlignedStorage; + // Directly manipulating the underlying allocation for performance, so requires unsafe pointers + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// The internal structure for the vector with a small array. struct ImplWithSmallArray { TStorage small_arr[N]; - tint::Slice slice = {&small_arr[0].Get(), 0, N}; + internal::Slice slice = {std::span{&small_arr[0].Get(), N}, 0}; /// Allocates a new vector of `T` either from #small_arr, or from the heap, then assigns the - /// pointer it to #slice.data, and updates #slice.cap. + /// pointer it to #slice.buffer. void Allocate(size_t new_cap) { - if (new_cap < N) { - slice.data = &small_arr[0].Get(); - slice.cap = N; + if (new_cap <= N) { + slice.buffer = {&small_arr[0].Get(), N}; } else { - slice.data = Bitcast(new TStorage[new_cap]); - slice.cap = new_cap; + slice.buffer = {Bitcast(new TStorage[new_cap]), new_cap}; } } - /// Frees `data`, if isn't a pointer to #small_arr - void Free(T* data) const { - if (data != &small_arr[0].Get()) { - delete[] Bitcast(data); + /// Frees `ptr`, if isn't a pointer to #small_arr + void Free(T* ptr) const { + if (ptr != &small_arr[0].Get()) { + delete[] reinterpret_cast(ptr); } } - /// Indicates whether the slice structure can be std::move()d. - /// @returns true if #slice.data does not point to #small_arr - bool CanMove() const { return slice.data != &small_arr[0].Get(); } + /// Indicates whether the structure can be std::move()d. + /// @returns true if #slice.buffer.data() does not point to #small_arr + bool CanMove() const { return slice.buffer.data() != &small_arr[0].Get(); } }; /// The internal structure for the vector without a small array. struct ImplWithoutSmallArray { - tint::Slice slice = Empty; + internal::Slice slice = {{}, 0}; - /// Allocates a new vector of `T` and assigns it to #slice.data, and updates #slice.cap. + /// Allocates a new vector of `T` and assigns it to #slice.buffer. void Allocate(size_t new_cap) { - slice.data = Bitcast(new TStorage[new_cap]); - slice.cap = new_cap; + slice.buffer = {reinterpret_cast(new TStorage[new_cap]), new_cap}; } - /// Frees `data`. - void Free(T* data) const { delete[] Bitcast(data); } + /// Frees `ptr`. + void Free(T* ptr) const { + if (ptr) { + delete[] reinterpret_cast(ptr); + } + } - /// Indicates whether the slice structure can be std::move()d. + /// Indicates whether the structure can be std::move()d. /// @returns true bool CanMove() const { return true; } }; + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// Either a ImplWithSmallArray or ImplWithoutSmallArray based on N. std::conditional_t impl_; @@ -986,11 +1133,9 @@ class Vector { mutable std::atomic iterator_count_ = 0; }; -namespace detail { +namespace internal { -/// Helper for determining the Vector element type (`T`) from the vector's constuctor arguments -/// @tparam IS_CASTABLE true if the types of `Ts` derive from CastableBase -/// @tparam Ts the vector constructor argument types to infer the vector element type from. +/// Helper for determining the Vector element type (`T`) from the vector's constructor arguments template struct VectorCommonType; @@ -1012,12 +1157,12 @@ struct VectorCommonType { common_ty*>; }; -} // namespace detail +} // namespace internal /// Helper for determining the Vector element type (`T`) from the vector's constuctor arguments template using VectorCommonType = - typename tint::detail::VectorCommonType...>, Ts...>::type; + tint::internal::VectorCommonType...>, Ts...>::type; /// Deduction guide for Vector template @@ -1046,128 +1191,191 @@ Vector(Ts...) -> Vector, sizeof...(Ts)>; /// Aside from this move pattern, a VectorRef provides an immutable reference to the Vector. template class VectorRef { - /// @returns an empty slice. - static tint::Slice& EmptySlice() { - static tint::Slice empty; - return empty; - } - public: /// Type of `T`. using value_type = T; /// Constructor - empty reference - VectorRef() : slice_(EmptySlice()) {} + VectorRef() : slice_(&local_slice_) {} /// Constructor - VectorRef(EmptyType) : slice_(EmptySlice()) {} // NOLINT(runtime/explicit) + // NOLINTNEXTLINE(google-explicit-constructor) + VectorRef(EmptyType) : slice_(&local_slice_) {} // NOLINT(runtime/explicit) - /// Constructor from a Slice - /// @param slice the slice - VectorRef(tint::Slice& slice) // NOLINT(runtime/explicit) - : slice_(slice) {} + /// Constructor from a span + /// @param span the span + // NOLINTNEXTLINE(google-explicit-constructor) + VectorRef(std::span span) // NOLINT(runtime/explicit) + : local_slice_{span}, slice_(&local_slice_) {} + + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + /// Constructor from a span + /// @param span the span + template + // NOLINTNEXTLINE(google-explicit-constructor) + VectorRef(std::span span) // NOLINT(runtime/explicit) + : local_slice_{std::span{Bitcast(span.data()), span.size()}, span.size()}, + slice_(&local_slice_) {} + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + + /// Constructor from an internal::Slice + /// @param slice the internal slice + // NOLINTNEXTLINE(google-explicit-constructor) + VectorRef(const internal::Slice& slice) // NOLINT(runtime/explicit) + : local_slice_(slice), slice_(&local_slice_) {} /// Constructor from a Vector /// @param vector the vector to create a reference of template + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(Vector& vector) // NOLINT(runtime/explicit) - : slice_(vector.impl_.slice) {} + : slice_(&vector.impl_.slice) {} /// Constructor from a const Vector /// @param vector the vector to create a reference of template + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(const Vector& vector) // NOLINT(runtime/explicit) - : slice_(const_cast&>(vector.impl_.slice)) {} + : slice_(const_cast*>(&vector.impl_.slice)) {} /// Constructor from a moved Vector /// @param vector the vector being moved template + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(Vector&& vector) // NOLINT(runtime/explicit) - : slice_(vector.impl_.slice), can_move_(vector.impl_.CanMove()) {} + : slice_(&vector.impl_.slice), can_move_(vector.impl_.CanMove()) {} /// Copy constructor /// @param other the vector reference - VectorRef(const VectorRef& other) : slice_(other.slice_) {} + VectorRef(const VectorRef& other) + : local_slice_(*other.slice_), + slice_(other.slice_ == &other.local_slice_ ? &local_slice_ : other.slice_) {} /// Move constructor /// @param other the vector reference - VectorRef(VectorRef&& other) = default; + VectorRef(VectorRef&& other) + : local_slice_(*other.slice_), + slice_(other.slice_ == &other.local_slice_ ? &local_slice_ : other.slice_), + can_move_(other.can_move_) { + other.can_move_ = false; + } + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// Copy constructor with covariance / const conversion /// @param other the other vector reference - template >> + template + requires(CanReinterpretSlice) + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(const VectorRef& other) // NOLINT(runtime/explicit) - : slice_(other.slice_.template Reinterpret()) {} + : local_slice_{std::span{Bitcast(other.begin()), other.Capacity()}, other.Length()}, + slice_(other.slice_ == &other.local_slice_ ? &local_slice_ + : Bitcast*>(other.slice_)) { + } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// Move constructor with covariance / const conversion /// @param other the vector reference - template >> + template + requires(CanReinterpretSlice) + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(VectorRef&& other) // NOLINT(runtime/explicit) - : slice_(other.slice_.template Reinterpret()), can_move_(other.can_move_) {} + : local_slice_{std::span{Bitcast(other.begin()), other.Capacity()}, other.Length()}, + slice_(other.slice_ == &other.local_slice_ ? &local_slice_ + : Bitcast*>(other.slice_)), + can_move_(other.can_move_) { + other.can_move_ = false; + } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// Constructor from a Vector with covariance / const conversion /// @param vector the vector to create a reference of /// @see CanReinterpretSlice for rules about conversion - template >> + template + requires(CanReinterpretSlice) + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(const Vector& vector) // NOLINT(runtime/explicit) - : slice_(const_cast&>(vector.impl_.slice).template Reinterpret()) {} + : slice_(reinterpret_cast*>( + const_cast*>(&vector.impl_.slice))) {} /// Constructor from a moved Vector with covariance / const conversion /// @param vector the vector to create a reference of /// @see CanReinterpretSlice for rules about conversion - template >> + template + requires(CanReinterpretSlice) + // NOLINTNEXTLINE(google-explicit-constructor) VectorRef(Vector&& vector) // NOLINT(runtime/explicit) - : slice_(vector.impl_.slice.template Reinterpret()), can_move_(vector.impl_.CanMove()) {} + : slice_(reinterpret_cast*>(&vector.impl_.slice)), + can_move_(vector.impl_.CanMove()) {} /// Index operator /// @param i the element index. Must be less than `len`. /// @returns a reference to the i'th element. - const T& operator[](size_t i) const { return slice_[i]; } + const T& operator[](size_t i) const { + TINT_ASSERT(i < Length()); + return slice_->buffer[i]; + } /// @return the number of elements in the vector - size_t Length() const { return slice_.len; } + size_t Length() const { return slice_->len; } /// @return the number of elements that the vector could hold before a heap allocation needs to /// be made - size_t Capacity() const { return slice_.cap; } + size_t Capacity() const { return slice_->buffer.size(); } + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); /// @return a reinterpretation of this VectorRef as elements of type U. /// @note this is doing a reinterpret_cast of elements. It is up to the caller to ensure that /// this is a safe operation. template VectorRef ReinterpretCast() const { - return {slice_.template Reinterpret()}; + return VectorRef{internal::Slice{ + std::span{Bitcast(slice_->buffer.data()), slice_->buffer.size()}, slice_->len}}; } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); - /// @returns the internal slice of the vector - tint::Slice Slice() { return slice_; } + // {ptr, size} style span construction will always cause this warning to fire + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + /// @returns the internal data of the vector as a std::span + std::span AsSpan() { return std::span{slice_->buffer.data(), slice_->len}; } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + + /// @returns the internal data of the vector as a std::span + std::span AsSpan() const { return slice_->buffer.subspan(0, slice_->len); } /// @returns true if the vector is empty. - bool IsEmpty() const { return slice_.len == 0; } + bool IsEmpty() const { return slice_->len == 0; } /// @returns a reference to the first element in the vector - const T& Front() const { return slice_.Front(); } + const T& Front() const { + TINT_ASSERT(!IsEmpty()); + return slice_->buffer.front(); + } /// @returns a reference to the last element in the vector - const T& Back() const { return slice_.Back(); } + const T& Back() const { + TINT_ASSERT(!IsEmpty()); + return slice_->buffer[slice_->len - 1]; + } /// @returns a pointer to the first element in the vector - const T* begin() const { return slice_.begin(); } + const T* begin() const { return slice_->buffer.data(); } + // STL end()/rbegin() is beyond the end of the span, so requires unsafe pointer math + TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// @returns a pointer to one past the last element in the vector - const T* end() const { return slice_.end(); } + const T* end() const { return slice_->buffer.data() + slice_->len; } /// @returns a reverse iterator starting with the last element in the vector - auto rbegin() const { return slice_.rbegin(); } + auto rbegin() const { return std::reverse_iterator(end()); } + TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); /// @returns the end for a reverse iterator - auto rend() const { return slice_.rend(); } + auto rend() const { return std::reverse_iterator(begin()); } /// @returns a hash code of the Vector tint::HashCode HashCode() const { @@ -1201,13 +1409,13 @@ class VectorRef { template friend class VectorRef; - /// Friend class - template - friend class VectorRef; + /// A local InternalSlice used when the VectorRef does not point to a Vector's internal slice. + internal::Slice local_slice_ = {{}, 0}; /// The slice of the vector being referenced. - tint::Slice& slice_; - /// Whether the slice data is passed by r-value reference, and can be moved. + internal::Slice* slice_ = nullptr; + + /// Whether the data is passed by r-value reference, and can be moved. bool can_move_ = false; }; @@ -1225,22 +1433,22 @@ std::vector ToStdVector(const Vector& vector) { return out; } -/// Helper for constructing a Vector from a Slice. Only the size must be supplied as the type is +/// Helper for constructing a Vector from a std::span. Only the size must be supplied as the type is /// deduced. -/// @param slice the input slice +/// @param span the input span /// @return the converted vector /// @note This helper is useful because Vectors require a size parameter, but because it is the /// second template parameter to a Vector, both the type and size parameters must be explicitly -/// declared. Furthermore, Slices are often of const pointer/reference type, but a Vector cannot be +/// declared. Furthermore, spans are often of const pointer/reference type, but a Vector cannot be /// of const pointer/reference type, again requiring the caller to be explicit. This helper makes it /// possible to only specify the size. template -auto ToVector(const tint::Slice& slice) { - // If Slice is of type 'T* const', make it 'T*' (or 'T& const', make it 'T&') as Vectors cannot +auto ToVector(std::span span) { + // If span is of type 'T* const', make it 'T*' (or 'T& const', make it 'T&') as Vectors cannot // be of const pointer/reference type. using U = std::conditional_t || std::is_reference_v, std::remove_const_t, T>; - return Vector{slice}; + return Vector{span}; } /// Helper for converting a std::vector to a Vector. @@ -1297,7 +1505,7 @@ auto& operator<<(STREAM& o, VectorRef vec) { return o; } -namespace detail { +namespace internal { /// IsVectorLike::value is true if T is a Vector or VectorRef. template @@ -1319,14 +1527,12 @@ struct IsVectorLike> { /// True for the IsVectorLike specialization of VectorRef static constexpr bool value = true; }; -} // namespace detail +} // namespace internal /// True if T is a Vector or VectorRef template -static constexpr bool IsVectorLike = tint::detail::IsVectorLike::value; +static constexpr bool IsVectorLike = tint::internal::IsVectorLike::value; } // namespace tint -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); - #endif // SRC_TINT_UTILS_CONTAINERS_VECTOR_H_ diff --git a/3rdparty/dawn/src/tint/utils/diagnostic/source.cc b/3rdparty/dawn/src/tint/utils/diagnostic/source.cc index 8b036e850..201851541 100644 --- a/3rdparty/dawn/src/tint/utils/diagnostic/source.cc +++ b/3rdparty/dawn/src/tint/utils/diagnostic/source.cc @@ -41,8 +41,7 @@ namespace { bool ParseLineBreak(std::string_view str, size_t i, bool* is_line_break, size_t* line_break_size) { // See https://www.w3.org/TR/WGSL/#blankspace - auto* utf8 = reinterpret_cast(&str[i]); - auto [cp, n] = tint::utf8::Decode(utf8, str.size() - i); + auto [cp, n] = tint::utf8::Decode(str.substr(i)); if (n == 0) { return false; @@ -68,8 +67,7 @@ bool ParseLineBreak(std::string_view str, size_t i, bool* is_line_break, size_t* *line_break_size = n; if (auto next_i = i + n; next_i < str.size()) { - auto* next_utf8 = reinterpret_cast(&str[next_i]); - auto [next_cp, next_n] = tint::utf8::Decode(next_utf8, str.size() - next_i); + auto [next_cp, next_n] = tint::utf8::Decode(str.substr(next_i)); if (next_n == 0) { return false; diff --git a/3rdparty/dawn/src/tint/utils/internal_limits.h b/3rdparty/dawn/src/tint/utils/internal_limits.h index 005d21cdd..503c695e9 100644 --- a/3rdparty/dawn/src/tint/utils/internal_limits.h +++ b/3rdparty/dawn/src/tint/utils/internal_limits.h @@ -53,6 +53,13 @@ constexpr int64_t kQuadSize = 4; // A @size attribute maximum size constexpr int64_t kMaxStructMemberPadding = 10 * 1024 * 1024; +// The maximum number of locations allowed for shader IO. +// This hard limit is derived from spirv-val (kMaxLocations in +// https://github.com/KhronosGroup/SPIRV-Tools/blob/main/source/val/validate_interfaces.cpp). +// Device-specific API limits will likely be much lower, but will be caught by Dawn before +// shader module generation. +constexpr uint32_t kMaxLocations = 4096; + } // namespace tint::internal_limits #endif // SRC_TINT_UTILS_INTERNAL_LIMITS_H_ diff --git a/3rdparty/dawn/src/tint/utils/macros/compiler.h b/3rdparty/dawn/src/tint/utils/macros/compiler.h index 79d0509b7..304fcdb3a 100644 --- a/3rdparty/dawn/src/tint/utils/macros/compiler.h +++ b/3rdparty/dawn/src/tint/utils/macros/compiler.h @@ -41,8 +41,9 @@ #define TINT_DISABLE_WARNING_CONSTANT_OVERFLOW __pragma(warning(disable : 4756)) #define TINT_DISABLE_WARNING_DEPRECATED __pragma(warning(disable : 4996)) #define TINT_DISABLE_WARNING_DESTRUCTOR_NEVER_RETURNS __pragma(warning(disable : 4722)) -#define TINT_DISABLE_WARNING_EXTRA_SEMICOLON /* currently no-op */ -#define TINT_DISABLE_WARNING_FLOAT_EQUAL /* currently no-op */ +#define TINT_DISABLE_WARNING_EXTRA_SEMICOLON /* currently no-op */ +#define TINT_DISABLE_WARNING_FLOAT_EQUAL /* currently no-op */ +#define TINT_DISABLE_WARNING_LIFETIME_SAFETY_INVALIDATION /* currently no-op */ #define TINT_DISABLE_WARNING_MAYBE_UNINITIALIZED __pragma(warning(disable : 4701)) #define TINT_DISABLE_WARNING_MISSING_DESTRUCTOR_OVERRIDE /* currently no-op */ #define TINT_DISABLE_WARNING_NEWLINE_EOF /* currently no-op */ @@ -55,7 +56,8 @@ #define TINT_DISABLE_WARNING_SIGN_CONVERSION /* currently no-op */ #define TINT_DISABLE_WARNING_UNDEFINED_REINTERPRET_CAST /* currently no-op */ #define TINT_DISABLE_WARNING_UNREACHABLE_CODE __pragma(warning(disable : 4702)) -#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE /* currently no-op */ +#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE /* currently no-op */ +#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE_IN_CONTAINER /* currently no-op */ #define TINT_DISABLE_WARNING_UNUSED_PARAMETER __pragma(warning(disable : 4100)) #define TINT_DISABLE_WARNING_UNSUED_VARIABLE __pragma(warning(disable : 4189)) #define TINT_DISABLE_WARNING_UNUSED_VALUE /* currently no-op */ @@ -107,6 +109,8 @@ #define TINT_DISABLE_WARNING_EXTRA_SEMICOLON \ _Pragma("clang diagnostic ignored \"-Wextra-semi-stmt\"") #define TINT_DISABLE_WARNING_FLOAT_EQUAL _Pragma("clang diagnostic ignored \"-Wfloat-equal\"") +#define TINT_DISABLE_WARNING_LIFETIME_SAFETY_INVALIDATION \ + _Pragma("clang diagnostic ignored \"-Wlifetime-safety-invalidation\"") #define TINT_DISABLE_WARNING_MAYBE_UNINITIALIZED \ _Pragma("clang diagnostic ignored \"-Wconditional-uninitialized\"") #define TINT_DISABLE_WARNING_MISSING_DESTRUCTOR_OVERRIDE \ @@ -133,6 +137,8 @@ #define TINT_DISABLE_WARNING_UNREACHABLE_CODE /* currently no-op */ #define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE \ _Pragma("clang diagnostic ignored \"-Wunsafe-buffer-usage\"") +#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE_IN_CONTAINER \ + _Pragma("clang diagnostic ignored \"-Wunsafe-buffer-usage-in-container\"") #define TINT_DISABLE_WARNING_UNUSED_PARAMETER \ _Pragma("clang diagnostic ignored \"-Wunused-parameter\"") #define TINT_DISABLE_WARNING_UNUSED_VALUE _Pragma("clang diagnostic ignored \"-Wunused-value\"") @@ -181,25 +187,26 @@ // GCC //////////////////////////////////////////////////////////////////////////////// #define TINT_BUILD_IS_GCC 1 -#define TINT_DISABLE_WARNING_CONSTANT_OVERFLOW /* currently no-op */ -#define TINT_DISABLE_WARNING_DEPRECATED /* currently no-op */ -#define TINT_DISABLE_WARNING_DESTRUCTOR_NEVER_RETURNS /* currently no-op */ -#define TINT_DISABLE_WARNING_EXTRA_SEMICOLON /* currently no-op */ -#define TINT_DISABLE_WARNING_FLOAT_EQUAL /* currently no-op */ -#define TINT_DISABLE_WARNING_MAYBE_UNINITIALIZED \ - _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -#define TINT_DISABLE_WARNING_MISSING_DESTRUCTOR_OVERRIDE /* currently no-op */ -#define TINT_DISABLE_WARNING_NEWLINE_EOF /* currently no-op */ -#define TINT_DISABLE_WARNING_OLD_STYLE_CAST /* currently no-op */ +#define TINT_DISABLE_WARNING_CONSTANT_OVERFLOW /* currently no-op */ +#define TINT_DISABLE_WARNING_DEPRECATED /* currently no-op */ +#define TINT_DISABLE_WARNING_DESTRUCTOR_NEVER_RETURNS /* currently no-op */ +#define TINT_DISABLE_WARNING_EXTRA_SEMICOLON /* currently no-op */ +#define TINT_DISABLE_WARNING_FLOAT_EQUAL /* currently no-op */ +#define TINT_DISABLE_WARNING_LIFETIME_SAFETY_INVALIDATION /* currently no-op */ +#define TINT_DISABLE_WARNING_MAYBE_UNINITIALIZED \ /* currently no-op */ +#define TINT_DISABLE_WARNING_MISSING_DESTRUCTOR_OVERRIDE /* currently no-op */ +#define TINT_DISABLE_WARNING_NEWLINE_EOF /* currently no-op */ +#define TINT_DISABLE_WARNING_OLD_STYLE_CAST /* currently no-op */ #define TINT_DISABLE_WARNING_PEDANTIC _Pragma("GCC diagnostic ignored \"-Wpedantic\"") -#define TINT_DISABLE_WARNING_REDUNDANT_PARENS /* currently no-op */ -#define TINT_DISABLE_WARNING_RESERVED_IDENTIFIER /* currently no-op */ -#define TINT_DISABLE_WARNING_RESERVED_MACRO_IDENTIFIER /* currently no-op */ -#define TINT_DISABLE_WARNING_SHADOW_FIELD_IN_CONSTRUCTOR /* currently no-op */ -#define TINT_DISABLE_WARNING_SIGN_CONVERSION /* currently no-op */ -#define TINT_DISABLE_WARNING_UNDEFINED_REINTERPRET_CAST /* currently no-op */ -#define TINT_DISABLE_WARNING_UNREACHABLE_CODE /* currently no-op */ -#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE /* currently no-op */ +#define TINT_DISABLE_WARNING_REDUNDANT_PARENS /* currently no-op */ +#define TINT_DISABLE_WARNING_RESERVED_IDENTIFIER /* currently no-op */ +#define TINT_DISABLE_WARNING_RESERVED_MACRO_IDENTIFIER /* currently no-op */ +#define TINT_DISABLE_WARNING_SHADOW_FIELD_IN_CONSTRUCTOR /* currently no-op */ +#define TINT_DISABLE_WARNING_SIGN_CONVERSION /* currently no-op */ +#define TINT_DISABLE_WARNING_UNDEFINED_REINTERPRET_CAST /* currently no-op */ +#define TINT_DISABLE_WARNING_UNREACHABLE_CODE /* currently no-op */ +#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE /* currently no-op */ +#define TINT_DISABLE_WARNING_UNSAFE_BUFFER_USAGE_IN_CONTAINER /* currently no-op */ #define TINT_DISABLE_WARNING_UNUSED_PARAMETER \ _Pragma("GCC diagnostic ignored \"-Wunused-parameter\"") #define TINT_DISABLE_WARNING_UNUSED_VALUE _Pragma("GCC diagnostic ignored \"-Wunused-value\"") @@ -233,6 +240,7 @@ TINT_DISABLE_WARNING_UNREACHABLE_CODE \ TINT_DISABLE_WARNING_WEAK_VTABLES \ TINT_DISABLE_WARNING_FLOAT_EQUAL \ + TINT_DISABLE_WARNING_LIFETIME_SAFETY_INVALIDATION \ TINT_DISABLE_WARNING_DEPRECATED \ TINT_DISABLE_WARNING_REDUNDANT_PARENS \ TINT_DISABLE_WARNING_RESERVED_IDENTIFIER \ diff --git a/3rdparty/dawn/src/tint/utils/math/math.h b/3rdparty/dawn/src/tint/utils/math/math.h index d0410521c..a31869310 100644 --- a/3rdparty/dawn/src/tint/utils/math/math.h +++ b/3rdparty/dawn/src/tint/utils/math/math.h @@ -102,7 +102,8 @@ inline constexpr uint64_t NextPowerOfTwo(uint64_t value) { /// @param value the input value /// @returns the largest power of two that `value` is a multiple of template -inline std::enable_if_t::value, T> MaxAlignOf(T value) { + requires(std::is_unsigned_v) +inline T MaxAlignOf(T value) { T pot = 1; while (value && ((value & 1u) == 0)) { pot <<= 1; diff --git a/3rdparty/dawn/src/tint/utils/memory/aligned_storage.h b/3rdparty/dawn/src/tint/utils/memory/aligned_storage.h index 7c533bb2f..a14790165 100644 --- a/3rdparty/dawn/src/tint/utils/memory/aligned_storage.h +++ b/3rdparty/dawn/src/tint/utils/memory/aligned_storage.h @@ -28,13 +28,12 @@ #ifndef SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_ #define SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_ +#include #include #include "src/tint/utils/macros/compiler.h" #include "src/tint/utils/memory/bitcast.h" -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); - namespace tint { /// A structure that has the same size and alignment as Entry. @@ -42,17 +41,15 @@ namespace tint { template struct alignas(alignof(T)) AlignedStorage { /// Byte array of length sizeof(T) - std::byte data[sizeof(T)]; + std::array data; /// @returns a pointer to aligned storage, reinterpreted as T& - T& Get() { return *Bitcast(&data[0]); } + T& Get() { return *Bitcast(data.data()); } /// @returns a pointer to aligned storage, reinterpreted as T& - const T& Get() const { return *Bitcast(&data[0]); } + const T& Get() const { return *Bitcast(data.data()); } }; } // namespace tint -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); - #endif // SRC_TINT_UTILS_MEMORY_ALIGNED_STORAGE_H_ diff --git a/3rdparty/dawn/src/tint/utils/memory/bitcast.h b/3rdparty/dawn/src/tint/utils/memory/bitcast.h index 9b0fa57f7..dea76d4c2 100644 --- a/3rdparty/dawn/src/tint/utils/memory/bitcast.h +++ b/3rdparty/dawn/src/tint/utils/memory/bitcast.h @@ -25,11 +25,6 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers -#endif - #ifndef SRC_TINT_UTILS_MEMORY_BITCAST_H_ #define SRC_TINT_UTILS_MEMORY_BITCAST_H_ @@ -37,6 +32,8 @@ #include #include +#include "src/utils/compiler.h" + namespace tint { /// Bitcast performs a cast of `from` to the `TO` type using a memcpy. @@ -61,8 +58,8 @@ inline TO Bitcast(FROM&& from) { static_assert(std::is_trivially_copyable_v>); static_assert(std::is_trivially_copyable_v>); TO to; - memcpy(reinterpret_cast(&to), reinterpret_cast(&from), - sizeof(TO)); + DAWN_UNSAFE_TODO(memcpy(reinterpret_cast(&to), + reinterpret_cast(&from), sizeof(TO))); return to; } diff --git a/3rdparty/dawn/src/tint/utils/memory/block_allocator.h b/3rdparty/dawn/src/tint/utils/memory/block_allocator.h index 2d682be5c..4e5481bab 100644 --- a/3rdparty/dawn/src/tint/utils/memory/block_allocator.h +++ b/3rdparty/dawn/src/tint/utils/memory/block_allocator.h @@ -59,10 +59,10 @@ class BlockAllocator { /// Pointers are allocated out of the block memory. struct Pointers { static constexpr size_t kMax = 32; - std::array ptrs; - Pointers* next; - Pointers* prev; - size_t count; + std::array ptrs = {}; + Pointers* next = nullptr; + Pointers* prev = nullptr; + size_t count = 0; }; /// Block is linked list of memory blocks. diff --git a/3rdparty/dawn/src/tint/utils/memory/bump_allocator.h b/3rdparty/dawn/src/tint/utils/memory/bump_allocator.h index 1e12484ca..cadbeda0a 100644 --- a/3rdparty/dawn/src/tint/utils/memory/bump_allocator.h +++ b/3rdparty/dawn/src/tint/utils/memory/bump_allocator.h @@ -55,7 +55,7 @@ class BumpAllocator { /// BlockHeader is linked list of memory blocks. /// Blocks are allocated out of heap memory. struct BlockHeader { - BlockHeader* next; + BlockHeader* next = nullptr; }; public: diff --git a/3rdparty/dawn/src/tint/utils/memory/copy.h b/3rdparty/dawn/src/tint/utils/memory/copy.h new file mode 100644 index 000000000..a8d17cdef --- /dev/null +++ b/3rdparty/dawn/src/tint/utils/memory/copy.h @@ -0,0 +1,139 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_TINT_UTILS_MEMORY_COPY_H_ +#define SRC_TINT_UTILS_MEMORY_COPY_H_ + +#include + +#include +#include + +#include "src/tint/utils/ice/ice.h" +#include "src/tint/utils/macros/compiler.h" + +// These wrappers around memcpy exist to localize the UNSAFE_BUFFER_USAGE warning intrinsic to the +// operation to one location. These warnings could be eliminated by using iteration to copy, but +// that would be less performant. std::ranges::copy does not guarantee bounds checking, so the +// warning still fires on some platforms. Chromium's //base has a more sophisticated implementation +// of this in the form of ::copy_from, but that is not available in standalone Dawn builds. +// +// It is intentional that the raw pointer -> std::span copy is not implemented, since that would +// involve crossing the boundary between unsafe -> safe memory operations. It is preferable for the +// call site where this is occurring be explicitly marked as unsafe, instead of trying to hide the +// warning. The idiomatic way to do this is to construct a std::span using the two-part constructor, +// which will need a warning suppression. And then call the std::span -> std::span version of Copy. +// +// There is an implementation of T -> std::span, so that stack allocated variables can be copied, +// without having to construct a span on the fly and suppress the associated warning. + +namespace tint { + +/// Copy copies all elements from @p src to @p dst. +/// @param dst the destination span +/// @param src the source span +/// @tparam T the type of destination elements +/// @tparam N the size of the destination span +/// @tparam U the type of source elements +/// @tparam M the size of the source span +// The usage of std::memcpy will always trigger this warning +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +template +inline void Copy(std::span dst, std::span src) { + TINT_ASSERT(src.data()); + TINT_ASSERT(dst.data()); + + // Check there is enough space in destination + static_assert(N * sizeof(T) >= M * sizeof(U)); + + // Allow for copies of different sized element types, iff the copy will be completely fill the + // elements it is using in destination + static_assert((M * sizeof(U)) % sizeof(T) == 0); + + if (!src.empty()) { + std::memcpy(dst.data(), src.data(), src.size_bytes()); + } +} +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + +/// Copy copies all elements from @p src to @p dst. +/// @param dst the destination pointer +/// @param dst_count the maximum number of elements that can be written to @p dst +/// @param src the source span +/// @tparam T the type of destination elements +/// @tparam U the type of source elements +/// @tparam M the size of the source span +// The usage of std::memcpy will always trigger this warning +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +template +inline void Copy(T* dst, size_t dst_count, std::span src) { + TINT_ASSERT(src.data()); + TINT_ASSERT(dst); + + // Check there is enough space in destination + TINT_ASSERT(dst_count * sizeof(T) >= src.size() * sizeof(U)); + + // Allow for copies of different sized element types, iff the copy will be completely fill the + // elements it is using in the destination + static_assert((M * sizeof(U)) % sizeof(T) == 0); + + if (!src.empty()) { + std::memcpy(dst, src.data(), src.size_bytes()); + } +} +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + +// template +// inline void Copy(std::span dest, T* src, size_t src_count) +// is intentionally omitted, see above + +/// Copy copies the bytes from a value @p src to a span @p dst. +/// @param dst the destination span +/// @param src the source value +/// @tparam T the type of destination elements +/// @tparam N the size of the destination span +/// @tparam U the type of source value +// The usage of std::memcpy will always trigger this warning +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +template +inline void Copy(std::span dst, U src) { + TINT_ASSERT(dst.data()); + + // Check there is enough space in destination + static_assert(N * sizeof(T) >= sizeof(U)); + + // Allow for copies of different sized element types, iff the copy will be completely fill the + // elements it is using in the destination + static_assert(sizeof(U) % sizeof(T) == 0); + + std::memcpy(dst.data(), &src, sizeof(U)); +} +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); + +} // namespace tint + +#endif // SRC_TINT_UTILS_MEMORY_COPY_H_ diff --git a/3rdparty/dawn/src/tint/utils/reflection.cc b/3rdparty/dawn/src/tint/utils/reflection/reflection.cc similarity index 98% rename from 3rdparty/dawn/src/tint/utils/reflection.cc rename to 3rdparty/dawn/src/tint/utils/reflection/reflection.cc index 33cc6aff8..125e0208e 100644 --- a/3rdparty/dawn/src/tint/utils/reflection.cc +++ b/3rdparty/dawn/src/tint/utils/reflection/reflection.cc @@ -25,7 +25,7 @@ // 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. -#include "src/tint/utils/reflection.h" +#include "src/tint/utils/reflection/reflection.h" #include "src/tint/utils/math/math.h" #include "src/tint/utils/text/string_stream.h" diff --git a/3rdparty/dawn/src/tint/utils/reflection.h b/3rdparty/dawn/src/tint/utils/reflection/reflection.h similarity index 78% rename from 3rdparty/dawn/src/tint/utils/reflection.h rename to 3rdparty/dawn/src/tint/utils/reflection/reflection.h index 451641aec..26a4a1782 100644 --- a/3rdparty/dawn/src/tint/utils/reflection.h +++ b/3rdparty/dawn/src/tint/utils/reflection/reflection.h @@ -25,10 +25,11 @@ // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -#ifndef SRC_TINT_UTILS_REFLECTION_H_ -#define SRC_TINT_UTILS_REFLECTION_H_ +#ifndef SRC_TINT_UTILS_REFLECTION_REFLECTION_H_ +#define SRC_TINT_UTILS_REFLECTION_REFLECTION_H_ #include +#include #include #include #include @@ -36,6 +37,7 @@ #include "src/tint/utils/containers/vector.h" #include "src/tint/utils/macros/foreach.h" +#include "src/tint/utils/macros/scoped_assignment.h" #include "src/tint/utils/memory/aligned_storage.h" #include "src/tint/utils/result.h" @@ -168,6 +170,79 @@ void ForeachField(const OBJECT& object, CB&& callback) { } } +/// Forward declaration of the recursive dispatcher for printing reflected values. +template + requires(traits::IsOStream) +void PrintValue(STREAM& ss, const T& value, std::string indent); + +/// Helper to print a reflected struct. +template + requires(traits::IsOStream && HasReflection) +void PrintReflected(STREAM& ss, const T& value, std::string indent = "") { + ss << T::Reflection::Name << "{\n"; + { + TINT_SCOPED_ASSIGNMENT(indent, indent + " "); + ForeachField(value, [&](const auto& field, std::string_view name) { + ss << indent << name << ": "; + PrintValue(ss, field, indent); + ss << "\n"; + }); + } + ss << indent << "}"; +} + +/// Main dispatcher function for formatting various reflected types. +template + requires(traits::IsOStream) +void PrintValue(STREAM& ss, const T& value, std::string indent) { + if constexpr (HasReflection) { + PrintReflected(ss, value, indent); + } else if constexpr (std::is_same_v, bool>) { + ss << (value ? "true" : "false"); + } else if constexpr (std::is_integral_v> || + std::is_floating_point_v>) { + ss << value; + } else if constexpr (requires { + value.begin(); + value.end(); + }) { + // Handle iterable containers (e.g. maps and vectors). + ss << "["; + for (const auto& item : value) { + // If this is a map pair, print the key and value. + if constexpr (requires { + item.first; + item.second; + }) { + TINT_SCOPED_ASSIGNMENT(indent, indent + " "); + ss << "\n" << indent << "{\n"; + { + TINT_SCOPED_ASSIGNMENT(indent, indent + " "); + ss << indent << "key: "; + PrintValue(ss, item.first, indent); + ss << "\n" << indent << "value: "; + PrintValue(ss, item.second, indent); + } + ss << "\n" << indent << "}"; + } else { + PrintValue(ss, item, indent); + } + } + ss << "]"; + } else if constexpr (requires { *value; }) { + // Handle std::optional. + if (value) { + PrintValue(ss, *value, indent); + } else { + ss << "std::nullopt"; + } + } else if constexpr (requires(STREAM& os, const T& v) { os << v; }) { + ss << value; + } else { + static_assert(sizeof(T) == 0, "unhandled type"); + } +} + /// Macro used by TINT_FOREACH() in TINT_REFLECT() to generate the T::Reflection::Fields tuple. #define TINT_REFLECT_FIELD_TYPE(FIELD) decltype(Class::FIELD), @@ -195,14 +270,6 @@ void ForeachField(const OBJECT& object, CB&& callback) { } \ } -/// TINT_REFLECT_EQUALS(CLASS) generates an operator== for the CLASS based on the reflected fields. -/// All reflected fields must be equality comparable. -#define TINT_REFLECT_EQUALS(CLASS) \ - bool operator==(const CLASS& other) const { \ - return CLASS::Reflection::FieldsAsTuple(*this) == CLASS::Reflection::FieldsAsTuple(other); \ - } \ - TINT_REQUIRE_SEMICOLON - /// TINT_REFLECT_HASH_CODE(CLASS) generates a tint::HashCode implementation for the CLASS based on /// the reflected fields. #define TINT_REFLECT_HASH_CODE(CLASS) \ @@ -234,4 +301,4 @@ struct EnumRange; } // namespace tint -#endif // SRC_TINT_UTILS_REFLECTION_H_ +#endif // SRC_TINT_UTILS_REFLECTION_REFLECTION_H_ diff --git a/3rdparty/dawn/src/tint/utils/strconv/float_to_string.cc b/3rdparty/dawn/src/tint/utils/strconv/float_to_string.cc index be915e8d5..1f81d4b79 100644 --- a/3rdparty/dawn/src/tint/utils/strconv/float_to_string.cc +++ b/3rdparty/dawn/src/tint/utils/strconv/float_to_string.cc @@ -25,11 +25,6 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers -#endif - #include "src/tint/utils/strconv/float_to_string.h" #include @@ -38,6 +33,7 @@ #include "src/tint/utils/ice/ice.h" #include "src/tint/utils/text/string_stream.h" +#include "src/utils/compiler.h" namespace tint::strconv { @@ -85,7 +81,7 @@ std::string ToBitPreservingString(F f) { typename T::uint_t float_bits = 0u; static_assert(sizeof(float_bits) == sizeof(f)); - std::memcpy(&float_bits, &f, sizeof(float_bits)); + DAWN_UNSAFE_TODO(std::memcpy(&float_bits, &f, sizeof(float_bits))); // Handle the sign. if (float_bits & T::kSignMask) { @@ -98,7 +94,7 @@ std::string ToBitPreservingString(F f) { switch (std::fpclassify(f)) { case FP_ZERO: case FP_NORMAL: - std::memcpy(&f, &float_bits, sizeof(float_bits)); + DAWN_UNSAFE_TODO(std::memcpy(&f, &float_bits, sizeof(float_bits))); ss << ToString(f); break; diff --git a/3rdparty/dawn/src/tint/utils/symbol/symbol_table.cc b/3rdparty/dawn/src/tint/utils/symbol/symbol_table.cc index f4a3e8ff9..63fbaa600 100644 --- a/3rdparty/dawn/src/tint/utils/symbol/symbol_table.cc +++ b/3rdparty/dawn/src/tint/utils/symbol/symbol_table.cc @@ -25,14 +25,10 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers -#endif - #include "src/tint/utils/symbol/symbol_table.h" #include "src/tint/utils/ice/ice.h" +#include "src/utils/compiler.h" namespace tint { @@ -101,7 +97,7 @@ std::string_view SymbolTable::Allocate(std::string_view name) { char* name_mem = Bitcast(name_allocator_.Allocate(name.length() + 1)); TINT_ASSERT(name_mem != nullptr) << "failed to allocate memory for symbol's string"; - memcpy(name_mem, name.data(), name.length() + 1); + DAWN_UNSAFE_TODO(memcpy(name_mem, name.data(), name.length() + 1)); return {name_mem, name.length()}; } diff --git a/3rdparty/dawn/src/tint/utils/templates/intrinsic_table_data.tmpl.inc b/3rdparty/dawn/src/tint/utils/templates/intrinsic_table_data.tmpl.inc index 489e722dc..6a9f038be 100644 --- a/3rdparty/dawn/src/tint/utils/templates/intrinsic_table_data.tmpl.inc +++ b/3rdparty/dawn/src/tint/utils/templates/intrinsic_table_data.tmpl.inc @@ -241,14 +241,14 @@ constexpr IntrinsicInfo kConstructorsAndConverters[] = { } // anonymous namespace const core::intrinsic::TableData {{$.Name}}{ - /* templates */ {{if .Templates}}kTemplates{{else}}Empty{{end}}, - /* type_matcher_indices */ {{if .MatcherIndices}}kMatcherIndices{{else}}Empty{{end}}, - /* type_matchers */ {{if .TMatchers}}kTypeMatchers{{else}}Empty{{end}}, - /* number_matchers */ {{if .NMatchers}}kNumberMatchers{{else}}Empty{{end}}, - /* parameters */ {{if .Parameters}}kParameters{{else}}Empty{{end}}, + /* templates */ {{if .Templates}}kTemplates{{else}}{}{{end}}, + /* type_matcher_indices */ {{if .MatcherIndices}}kMatcherIndices{{else}}{}{{end}}, + /* type_matchers */ {{if .TMatchers}}kTypeMatchers{{else}}{}{{end}}, + /* number_matchers */ {{if .NMatchers}}kNumberMatchers{{else}}{}{{end}}, + /* parameters */ {{if .Parameters}}kParameters{{else}}{}{{end}}, /* overloads */ kOverloads, - /* const_eval_functions */ {{if .ConstEvalFunctions}}kConstEvalFunctions{{else}}Empty{{end}}, - /* ctor_conv */ {{if .ConstructorsAndConverters}}kConstructorsAndConverters{{else}}Empty{{end}}, + /* const_eval_functions */ {{if .ConstEvalFunctions}}kConstEvalFunctions{{else}}{}{{end}}, + /* ctor_conv */ {{if .ConstructorsAndConverters}}kConstructorsAndConverters{{else}}{}{{end}}, /* builtins */ kBuiltins, {{- range $op := List "+" "-" "*" "/" "%" "^" "&" "|" "&&" "||" "==" "!=" "<" ">" "<=" ">=" "<<" ">>"}} {{- $N := Eval "OperatorName" $op }} diff --git a/3rdparty/dawn/src/tint/utils/text/base64.cc b/3rdparty/dawn/src/tint/utils/text/base64.cc index ea498e520..7a9731585 100644 --- a/3rdparty/dawn/src/tint/utils/text/base64.cc +++ b/3rdparty/dawn/src/tint/utils/text/base64.cc @@ -27,8 +27,11 @@ #include "src/tint/utils/text/base64.h" +#include #include +#include "src/tint/utils/result.h" + namespace tint { Vector DecodeBase64FromComments(std::string_view wgsl) { @@ -68,4 +71,23 @@ Vector DecodeBase64FromComments(std::string_view wgsl) { return out; } +Result EncodeBase64(std::span data) { + constexpr std::array kMap{ + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', + 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', + 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', + 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', + }; + std::string out; + out.reserve(data.size()); + for (std::byte b : data) { + const auto val = static_cast(b); + if (val >= kMap.size()) { + return Failure{"byte value " + std::to_string(val) + " is out of range [0, 63]"}; + } + out.push_back(kMap[val]); + } + return out; +} + } // namespace tint diff --git a/3rdparty/dawn/src/tint/utils/text/base64.h b/3rdparty/dawn/src/tint/utils/text/base64.h index 1047c3355..b85a380d2 100644 --- a/3rdparty/dawn/src/tint/utils/text/base64.h +++ b/3rdparty/dawn/src/tint/utils/text/base64.h @@ -30,11 +30,20 @@ #include #include +#include #include "src/tint/utils/containers/vector.h" +#include "src/tint/utils/result.h" namespace tint { +// Note: that Decode and Encode are not guaranteed to be a perfect roundtrip, because the value +// calculated by Decode is based on all the comments in the WGSL file, and the intended usage of +// encode is to be used as part of emitting a single comment string. +// So for this sequence: multiple comments -> Encode -> binary -> Decode, you will get a single +// string to put in a comment. The data when parsed should be equivalent though, you are just not +// guaranteed to get the exact same text out. + /// Decodes a byte from a base64 encoded character /// @param c the character to decode /// @return the decoded value, or std::nullopt if the character is padding ('=') or an invalid @@ -63,6 +72,11 @@ inline std::optional DecodeBase64(char c) { /// @return the base64 decoded bytes Vector DecodeBase64FromComments(std::string_view wgsl); +/// EncodeBase64 encodes a byte stream as a base64 string +/// @param data the data to encode +/// @return the base64 encoded string, or Failure if a byte is not in the range [0, 63] +Result EncodeBase64(std::span data); + } // namespace tint #endif // SRC_TINT_UTILS_TEXT_BASE64_H_ diff --git a/3rdparty/dawn/src/tint/utils/text/string.cc b/3rdparty/dawn/src/tint/utils/text/string.cc index daf8fc68c..642477c4a 100644 --- a/3rdparty/dawn/src/tint/utils/text/string.cc +++ b/3rdparty/dawn/src/tint/utils/text/string.cc @@ -65,7 +65,7 @@ size_t Distance(std::string_view str_a, std::string_view str_b) { } void SuggestAlternatives(std::string_view got, - Slice strings, + std::span strings, StyledText& ss, const SuggestAlternativeOptions& options /* = {} */) { // If the string typed was within kSuggestionDistance of one of the possible enum values, diff --git a/3rdparty/dawn/src/tint/utils/text/string.h b/3rdparty/dawn/src/tint/utils/text/string.h index c2f9a1b88..40f58045f 100644 --- a/3rdparty/dawn/src/tint/utils/text/string.h +++ b/3rdparty/dawn/src/tint/utils/text/string.h @@ -28,10 +28,10 @@ #ifndef SRC_TINT_UTILS_TEXT_STRING_H_ #define SRC_TINT_UTILS_TEXT_STRING_H_ +#include #include #include -#include "src/tint/utils/containers/slice.h" #include "src/tint/utils/containers/vector.h" #include "src/tint/utils/text/string_stream.h" #include "src/tint/utils/text/text_style.h" @@ -88,7 +88,7 @@ struct SuggestAlternativeOptions { /// @param ss the stream to write the suggest and list of possible values to /// @param options options for the suggestion void SuggestAlternatives(std::string_view got, - Slice strings, + std::span strings, StyledText& ss, const SuggestAlternativeOptions& options = {}); diff --git a/3rdparty/dawn/src/tint/utils/text/string_stream.h b/3rdparty/dawn/src/tint/utils/text/string_stream.h index 49b3d2f7c..20971ba69 100644 --- a/3rdparty/dawn/src/tint/utils/text/string_stream.h +++ b/3rdparty/dawn/src/tint/utils/text/string_stream.h @@ -76,8 +76,8 @@ class StringStream { /// Emit `value` to the stream /// @param value the value to emit /// @returns a reference to this - template >, bool> = true> + template + requires(std::is_integral_v>) StringStream& operator<<(T&& value) { return EmitValue(std::forward(value)); } @@ -103,8 +103,8 @@ class StringStream { /// Emit `value` to the stream /// @param value the value to emit /// @returns a reference to this - template >, bool> = true> + template + requires(std::is_floating_point_v>) StringStream& operator<<(T&& value) { return EmitFloat(std::forward(value)); } @@ -160,7 +160,7 @@ class StringStream { } /// Swaps streams - /// @param other stream to swap too + /// @param other stream to swap to void swap(StringStream& other) { sstream_.swap(other.sstream_); } /// repeat queues the character c to be written to the printer n times. @@ -171,27 +171,28 @@ class StringStream { /// The callback to emit a `endl` to the stream using StdEndl = std::ostream& (*)(std::ostream&); - /// @param manipulator the callback to emit too + /// @param manipulator the callback to emit to /// @returns a reference to this StringStream& operator<<(StdEndl manipulator) { - // call the function, and return it's value + // call the function, and return its value manipulator(sstream_); return *this; } - /// @param manipulator the callback to emit too + /// @param manipulator the callback to emit to /// @returns a reference to this StringStream& operator<<(decltype(std::hex) manipulator) { - // call the function, and return it's value + // call the function, and return its value manipulator(sstream_); return *this; } /// @param value the value to emit /// @returns a reference to this - template , int> = 0> + template + requires(IsSetType) StringStream& operator<<(T&& value) { - // call the function, and return it's value + // call the function, and return its value sstream_ << std::forward(value); return *this; } diff --git a/3rdparty/dawn/src/tint/utils/text/styled_text_printer.cc b/3rdparty/dawn/src/tint/utils/text/styled_text_printer.cc index f73dbe2fe..b6850ea30 100644 --- a/3rdparty/dawn/src/tint/utils/text/styled_text_printer.cc +++ b/3rdparty/dawn/src/tint/utils/text/styled_text_printer.cc @@ -25,16 +25,12 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers -#endif - #include "src/tint/utils/text/styled_text_printer.h" #include #include "src/tint/utils/system/terminal.h" +#include "src/utils/compiler.h" namespace tint { namespace { @@ -45,7 +41,7 @@ class Plain : public StyledTextPrinter { void Print(const StyledText& text) override { auto plain = text.Plain(); - fwrite(plain.data(), 1, plain.size(), file_); + DAWN_UNSAFE_TODO(fwrite(plain.data(), 1, plain.size(), file_)); } private: diff --git a/3rdparty/dawn/src/tint/utils/text/styled_text_printer_ansi.cc b/3rdparty/dawn/src/tint/utils/text/styled_text_printer_ansi.cc index 03475ad8d..52f39db22 100644 --- a/3rdparty/dawn/src/tint/utils/text/styled_text_printer_ansi.cc +++ b/3rdparty/dawn/src/tint/utils/text/styled_text_printer_ansi.cc @@ -25,11 +25,6 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers -#endif - #include #include @@ -38,6 +33,7 @@ #include "src/tint/utils/text/styled_text_printer.h" #include "src/tint/utils/text/styled_text_theme.h" #include "src/tint/utils/text/text_style.h" +#include "src/utils/compiler.h" namespace tint { namespace { @@ -102,7 +98,7 @@ class Printer24Bit : public StyledTextPrinter { fprintf(file_, ESCAPE "[22m"); } } - fwrite(text.data(), 1, text.size(), file_); + DAWN_UNSAFE_TODO(fwrite(text.data(), 1, text.size(), file_)); }); fprintf(file_, ESCAPE "[m"); fflush(file_); @@ -188,7 +184,7 @@ class Printer8Bit : public StyledTextPrinter { fprintf(file_, ESCAPE "[22m"); } } - fwrite(text.data(), 1, text.size(), file_); + DAWN_UNSAFE_TODO(fwrite(text.data(), 1, text.size(), file_)); }); fprintf(file_, ESCAPE "[m"); fflush(file_); diff --git a/3rdparty/dawn/src/tint/utils/text/text_style.h b/3rdparty/dawn/src/tint/utils/text/text_style.h index bd9f08730..60c4a1551 100644 --- a/3rdparty/dawn/src/tint/utils/text/text_style.h +++ b/3rdparty/dawn/src/tint/utils/text/text_style.h @@ -3,8 +3,7 @@ // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // -// 1. Redistributions of source code must retain the above copyright notice, -// this +// 1. Redistributions of source code must retain the above copyright notice, this // list of conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright notice, @@ -17,15 +16,14 @@ // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE -// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR -// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF -// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS -// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN -// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) -// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -// POSSIBILITY OF SUCH DAMAGE. +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef SRC_TINT_UTILS_TEXT_TEXT_STYLE_H_ #define SRC_TINT_UTILS_TEXT_TEXT_STYLE_H_ diff --git a/3rdparty/dawn/src/tint/utils/text/unicode.cc b/3rdparty/dawn/src/tint/utils/text/unicode.cc index 450f81d12..0ec68bf0b 100644 --- a/3rdparty/dawn/src/tint/utils/text/unicode.cc +++ b/3rdparty/dawn/src/tint/utils/text/unicode.cc @@ -30,6 +30,7 @@ #include #include +#include "src/tint/utils/ice/ice.h" #include "src/tint/utils/macros/compiler.h" namespace tint { @@ -372,48 +373,51 @@ uint8_t SequenceLength(uint8_t first_code_point) { return kSequenceLength[first_code_point]; } -// This is a C-style API that will always trigger -Wunsafe-buffer-usage -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); -std::pair Decode(const uint8_t* ptr, size_t len) { - if (len < 1) { +std::pair Decode(std::span buffer) { + if (buffer.empty()) { return {}; } // Fast-path ASCII characters as they're always valid - if (ptr[0] <= 0x7f) { - return {CodePoint{ptr[0]}, 1}; + if (buffer[0] <= 0x7f) { + return {CodePoint{buffer[0]}, 1}; } - uint8_t n = SequenceLength(ptr[0]); - if (n > len) { + uint8_t n = SequenceLength(buffer[0]); + if (n > buffer.size() || n == 0) { return {}; } CodePoint c; - uint8_t top_bits = 0b11000000; switch (n) { // Note: n=0 (invalid) is correctly handled without a case. case 1: - c = CodePoint{ptr[0]}; + c = CodePoint{buffer.first<1>()[0]}; break; - case 2: - top_bits &= ptr[1] ^ 0b01000000; - c = CodePoint{(static_cast(ptr[0] & 0b00011111) << 6) | - (static_cast(ptr[1] & 0b00111111))}; + case 2: { + const auto view = buffer.first<2>(); + top_bits &= view[1] ^ 0b01000000; + c = CodePoint{(static_cast(view[0] & 0b00011111) << 6) | + (static_cast(view[1] & 0b00111111))}; break; - case 3: - top_bits &= (ptr[1] ^ 0b01000000) & (ptr[2] ^ 0b01000000); - c = CodePoint{(static_cast(ptr[0] & 0b00001111) << 12) | - (static_cast(ptr[1] & 0b00111111) << 6) | - (static_cast(ptr[2] & 0b00111111))}; + } + case 3: { + const auto view = buffer.first<3>(); + top_bits &= (view[1] ^ 0b01000000) & (view[2] ^ 0b01000000); + c = CodePoint{(static_cast(view[0] & 0b00001111) << 12) | + (static_cast(view[1] & 0b00111111) << 6) | + (static_cast(view[2] & 0b00111111))}; break; - case 4: - top_bits &= (ptr[1] ^ 0b01000000) & (ptr[2] ^ 0b01000000) & (ptr[3] ^ 0b01000000); - c = CodePoint{(static_cast(ptr[0] & 0b00000111) << 18) | - (static_cast(ptr[1] & 0b00111111) << 12) | - (static_cast(ptr[2] & 0b00111111) << 6) | - (static_cast(ptr[3] & 0b00111111))}; + } + case 4: { + const auto view = buffer.first<4>(); + top_bits &= (view[1] ^ 0b01000000) & (view[2] ^ 0b01000000) & (view[3] ^ 0b01000000); + c = CodePoint{(static_cast(view[0] & 0b00000111) << 18) | + (static_cast(view[1] & 0b00111111) << 12) | + (static_cast(view[2] & 0b00111111) << 6) | + (static_cast(view[3] & 0b00111111))}; break; + } } if (top_bits != 0b11000000) { // Check that the two most significant bits of all the code units after the first code point @@ -434,48 +438,70 @@ std::pair Decode(const uint8_t* ptr, size_t len) { return {c, n}; } -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); -std::pair Decode(std::string_view utf8_string) { - return Decode(reinterpret_cast(utf8_string.data()), utf8_string.size()); -} - -// This is a C-style API that will always trigger -Wunsafe-buffer-usage +// For most common platform sizeof(std::byte) == sizeof(uint8_t), but is not guaranteed by the spec, +// which is why the compiler will not use Decode(uint8_t) when passing in a std::byte span. The use +// of two-part span constructor is what causes the IN_CONTAINER warning. The other warning is +// because the compiler cannot statically guarantee the calculation for size to the constructor, if +// the sizes are not equal. +// tint::Copy could be used here and below to remove the need for a suppression here, but that +// would be less performant and as well as just hiding the need for a suppression. +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); -size_t Encode(CodePoint code_point, uint8_t* ptr) { +std::pair Decode(std::span buffer) { + TINT_ASSERT(buffer.data()); + return Decode({reinterpret_cast(buffer.data()), + buffer.size() * sizeof(std::byte) / sizeof(uint8_t)}); +} +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + +// Converting the string_view to a span requires usage of the two-part span constructor which will +// always trigger this warning. +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); +std::pair Decode(std::string_view utf8_string) { + TINT_ASSERT(utf8_string.data()); + auto buf = std::span{utf8_string.data(), utf8_string.size()}; + return Decode(std::as_bytes(buf)); +} +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + +size_t Encode(CodePoint code_point, std::span buffer) { if (code_point <= 0x7f) { - if (ptr) { - ptr[0] = static_cast(code_point); + if (buffer.size() >= 1) { + buffer.first<1>()[0] = static_cast(code_point); } return 1; } if (code_point <= 0x7ff) { - if (ptr) { - ptr[0] = static_cast(code_point >> 6) | 0b11000000; - ptr[1] = static_cast(code_point & 0b00111111) | 0b10000000; + if (buffer.size() >= 2) { + auto view = buffer.first<2>(); + view[0] = static_cast(code_point >> 6) | 0b11000000; + view[1] = static_cast(code_point & 0b00111111) | 0b10000000; } return 2; } if (code_point <= 0xffff) { - if (ptr) { - ptr[0] = static_cast(code_point >> 12) | 0b11100000; - ptr[1] = static_cast((code_point >> 6) & 0b00111111) | 0b10000000; - ptr[2] = static_cast(code_point & 0b00111111) | 0b10000000; + if (buffer.size() >= 3) { + auto view = buffer.first<3>(); + view[0] = static_cast(code_point >> 12) | 0b11100000; + view[1] = static_cast((code_point >> 6) & 0b00111111) | 0b10000000; + view[2] = static_cast(code_point & 0b00111111) | 0b10000000; } return 3; } if (code_point <= 0x10ffff) { - if (ptr) { - ptr[0] = static_cast(code_point >> 18) | 0b11110000; - ptr[1] = static_cast((code_point >> 12) & 0b00111111) | 0b10000000; - ptr[2] = static_cast((code_point >> 6) & 0b00111111) | 0b10000000; - ptr[3] = static_cast(code_point & 0b00111111) | 0b10000000; + if (buffer.size() >= 4) { + auto view = buffer.first<4>(); + view[0] = static_cast(code_point >> 18) | 0b11110000; + view[1] = static_cast((code_point >> 12) & 0b00111111) | 0b10000000; + view[2] = static_cast((code_point >> 6) & 0b00111111) | 0b10000000; + view[3] = static_cast(code_point & 0b00111111) | 0b10000000; } return 4; } return 0; // invalid code point } -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); bool IsASCII(std::string_view str) { for (auto c : str) { @@ -486,54 +512,124 @@ bool IsASCII(std::string_view str) { return true; } +bool IsIdentifier(std::string_view str) { + if (str.empty()) { + return false; + } + auto is_alpha_or_underscore = [](char c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'; + }; + auto is_digit = [](char c) { return c >= '0' && c <= '9'; }; + if (!is_alpha_or_underscore(str.front())) { + return false; + } + for (size_t i = 1; i < str.length(); i++) { + if (!is_alpha_or_underscore(str[i]) && !is_digit(str[i])) { + return false; + } + } + return true; +} + +bool IsWGSLIdentifier(std::string_view str) { + if (str.empty()) { + return false; + } + + // Identifiers must not start with two or more underscores. + if (str.length() > 1 && str[0] == '_' && str[1] == '_') { + return false; + } + + // Must begin with an XID_Source unicode character, or underscore + auto [first_cp, first_n] = Decode(str); + if (first_n == 0 || (first_cp != '_' && !first_cp.IsXIDStart())) { + return false; + } + + // Must continue with an XID_Continue unicode character + str.remove_prefix(first_n); + while (!str.empty()) { + auto [cp, n] = Decode(str); + if (n == 0 || !cp.IsXIDContinue()) { + return false; + } + str.remove_prefix(n); + } + + return true; +} + } // namespace utf8 namespace utf16 { -// This is a C-style API that will always trigger -Wunsafe-buffer-usage -TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); -std::pair Decode(const uint16_t* ptr, size_t len) { - if (len < 1) { +std::pair Decode(std::span buffer) { + if (buffer.empty()) { return {}; } - uint16_t a = ptr[0]; + uint16_t a = buffer.first<1>()[0]; if (a <= 0xd7ff || a >= 0xe000) { return {CodePoint{static_cast(a)}, 1}; } - if (len < 2) { + if (buffer.size() < 2) { return {}; } - uint32_t b = ptr[1]; + + const auto view = buffer.first<2>(); + const uint32_t b = view[1]; if (b <= 0xd7ff || b >= 0xe000) { return {}; } - uint32_t high = a - 0xd800; - uint32_t low = b - 0xdc00; + const uint32_t high = a - 0xd800; + const uint32_t low = b - 0xdc00; return {CodePoint{0x10000 + ((high << 10) | low)}, 2}; } -std::pair Decode(std::string_view utf16_string) { - return Decode(reinterpret_cast(utf16_string.data()), utf16_string.size() / 2); +// For most platforms sizeof(std::byte) != sizeof(uint16_t), so there needs to be a reinterpretation +// here, which needs the two-part span constructor. This causes the IN_CONTAINER warning. The other +// warning is because the compiler cannot statically guarantee the calculation for size to the +// constructor. +// tint::Copy could be used here and below to remove the need for a suppression here, but that +// would be less performant and as well as just hiding the need for a suppression. +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +std::pair Decode(std::span buffer) { + TINT_ASSERT(buffer.data()); + return Decode({reinterpret_cast(buffer.data()), + buffer.size() * sizeof(std::byte) / sizeof(uint16_t)}); } +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); -size_t Encode(CodePoint code_point, uint16_t* ptr) { +// Converting the string_view to a span requires usage of the two-part span constructor which will +// always trigger this warning. +TINT_BEGIN_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); +std::pair Decode(std::string_view utf16_string) { + TINT_ASSERT(utf16_string.data()); + auto buf = std::span{utf16_string.data(), utf16_string.size()}; + return Decode(std::as_bytes(buf)); +} +TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE_IN_CONTAINER); + +size_t Encode(CodePoint code_point, std::span buffer) { if (code_point <= 0xd7ff || (code_point >= 0xe000 && code_point <= 0xffff)) { - if (ptr) { - ptr[0] = static_cast(code_point); + if (buffer.size() >= 1) { + buffer.first<1>()[0] = static_cast(code_point); } return 1; } if (code_point >= 0x10000 && code_point <= 0x10ffff) { - if (ptr) { + if (buffer.size() >= 2) { + auto view = buffer.first<2>(); auto biased = code_point - 0x10000; - ptr[0] = static_cast((biased >> 10) + 0xd800); - ptr[1] = static_cast((biased & 0b1111111111) + 0xdc00); + view[0] = static_cast((biased >> 10) + 0xd800); + view[1] = static_cast((biased & 0b1111111111) + 0xdc00); } return 2; } return 0; // invalid code point } -TINT_END_DISABLE_WARNING(UNSAFE_BUFFER_USAGE); } // namespace utf16 } // namespace tint diff --git a/3rdparty/dawn/src/tint/utils/text/unicode.h b/3rdparty/dawn/src/tint/utils/text/unicode.h index 50d5150bd..adb7257c1 100644 --- a/3rdparty/dawn/src/tint/utils/text/unicode.h +++ b/3rdparty/dawn/src/tint/utils/text/unicode.h @@ -30,6 +30,7 @@ #include #include +#include #include #include @@ -75,11 +76,18 @@ namespace utf8 { uint8_t SequenceLength(uint8_t first_code_point); /// Decodes the first code point in the utf8 string. -/// @param ptr the pointer to the first byte of the utf8 sequence -/// @param len the maximum number of uint8_t to read +/// @param buffer the buffer containing the utf8 sequence /// @returns a pair of CodePoint and width in code units (uint8_t). /// If the next code point cannot be decoded then returns [0,0]. -std::pair Decode(const uint8_t* ptr, size_t len); +std::pair Decode(std::span buffer); + +/// Decodes the first code point in the utf8 string. +/// Note: This cannot be handled via the uint8_t version, because std::byte is not guaranteed to be +/// 8-bits wide in the spec. +/// @param buffer the buffer containing the utf8 sequence +/// @returns a pair of CodePoint and width in code units (uint8_t). +/// If the next code point cannot be decoded then returns [0,0]. +std::pair Decode(std::span buffer); /// Decodes the first code point in the utf8 string. /// @param utf8_string the string view that contains the utf8 sequence @@ -90,25 +98,38 @@ std::pair Decode(std::string_view utf8_string); /// Encodes a code point to the utf8 string buffer or queries the number of code units used to /// encode the code point. /// @param code_point the code point to encode. -/// @param ptr the pointer to the utf8 string buffer, or nullptr to query the number of code units -/// that would be written if @p ptr is not nullptr. +/// @param buffer the utf8 string buffer, or an empty span to query the number of code units +/// that would be written if @p buffer had sufficient space. /// @returns the number of code units written / would be written (at most 4). -size_t Encode(CodePoint code_point, uint8_t* ptr); +size_t Encode(CodePoint code_point, std::span buffer); /// @returns true if all the utf-8 code points in the string are ASCII /// (code-points 0x00..0x7f). bool IsASCII(std::string_view); +/// @returns true if the string is a valid identifier (starts with a letter or underscore, +/// followed by letters, numbers, or underscores). +bool IsIdentifier(std::string_view); + +/// @returns true if the string is a valid WGSL identifier. +/// @see https://www.w3.org/TR/WGSL/#identifiers +bool IsWGSLIdentifier(std::string_view); + } // namespace utf8 namespace utf16 { /// Decodes the first code point in the utf16 string. -/// @param ptr the pointer to the first byte of the utf16 sequence -/// @param len the maximum number of code units to read +/// @param buffer the buffer containing the utf16 sequence /// @returns a pair of CodePoint and width in code units (16-bit integers). /// If the next code point cannot be decoded then returns [0,0]. -std::pair Decode(const uint16_t* ptr, size_t len); +std::pair Decode(std::span buffer); + +/// Decodes the first code point in the utf16 string. +/// @param buffer the buffer containing the utf16 sequence +/// @returns a pair of CodePoint and width in code units (16-bit integers). +/// If the next code point cannot be decoded then returns [0,0]. +std::pair Decode(std::span buffer); /// Decodes the first code point in the utf16 string. /// @param utf16_string the string view that contains the utf16 sequence @@ -119,10 +140,10 @@ std::pair Decode(std::string_view utf16_string); /// Encodes a code point to the utf16 string buffer or queries the number of code units used to /// encode the code point. /// @param code_point the code point to encode. -/// @param ptr the pointer to the utf16 string buffer, or nullptr to query the number of code units -/// that would be written if @p ptr is not nullptr. +/// @param buffer the utf16 string buffer, or an empty span to query the number of code units +/// that would be written if @p buffer had sufficient space. /// @returns the number of code units written / would be written (at most 2). -size_t Encode(CodePoint code_point, uint16_t* ptr); +size_t Encode(CodePoint code_point, std::span buffer); } // namespace utf16 diff --git a/3rdparty/dawn/src/tint/utils/bytes/endianness.h b/3rdparty/dawn/src/utils/assert.cc similarity index 70% rename from 3rdparty/dawn/src/tint/utils/bytes/endianness.h rename to 3rdparty/dawn/src/utils/assert.cc index 9eeacbf5f..0b46b21e3 100644 --- a/3rdparty/dawn/src/tint/utils/bytes/endianness.h +++ b/3rdparty/dawn/src/utils/assert.cc @@ -1,4 +1,4 @@ -// Copyright 2023 The Dawn & Tint Authors +// Copyright 2017 The Dawn & Tint Authors // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -25,28 +25,26 @@ // 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 UNSAFE_BUFFERS_BUILD -// TODO(crbug.com/439062058): Remove this and convert code to safer constructs. -#pragma allow_unsafe_buffers +#include "src/utils/assert.h" + +#include + +#include "src/utils/force_crash.h" +#include "src/utils/log.h" + +namespace dawn { + +void HandleAssertionFailure(const char* file, + const char* function, + int line, + const char* condition) { + dawn::ErrorLog() << "Assertion failure at " << file << ":" << line << " (" << function + << "): " << condition; +#if defined(DAWN_ABORT_ON_ASSERT) + abort(); +#else + DAWN_FORCE_CRASH(); #endif - -#ifndef SRC_TINT_UTILS_BYTES_ENDIANNESS_H_ -#define SRC_TINT_UTILS_BYTES_ENDIANNESS_H_ - -#include -#include - -namespace tint::bytes { - -enum class Endianness : uint8_t { kBig, kLittle }; - -inline Endianness NativeEndianness() { - uint8_t u8[4]; - uint32_t u32 = 0x01020304; - memcpy(u8, &u32, 4); - return u8[0] == 1 ? Endianness::kBig : Endianness::kLittle; } -} // namespace tint::bytes - -#endif // SRC_TINT_UTILS_BYTES_ENDIANNESS_H_ +} // namespace dawn diff --git a/3rdparty/dawn/src/utils/assert.h b/3rdparty/dawn/src/utils/assert.h new file mode 100644 index 000000000..39ae18e00 --- /dev/null +++ b/3rdparty/dawn/src/utils/assert.h @@ -0,0 +1,144 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_UTILS_ASSERT_H_ +#define SRC_UTILS_ASSERT_H_ + +#include +#include + +#include "src/utils/compiler.h" + +// Dawn asserts to be used instead of the regular C stdlib assert function (if you don't use assert +// yet, you should start now!). In debug DAWN_ASSERT(condition) will trigger an error, otherwise in +// release it does nothing at runtime. +// +// In case of name clashes (with for example a testing library), you can define the +// DAWN_SKIP_ASSERT_SHORTHANDS to only define the DAWN_ prefixed macros. +// +// These asserts feature: +// - Logging of the error with file, line and function information. +// - Breaking in the debugger when an assert is triggered and a debugger is attached. +// - Use the assert information to help the compiler optimizer in release builds. + +// MSVC triggers a warning in /W4 for do {} while(0). SDL worked around this by using (0,0) and +// points out that it looks like an owl face. +#if DAWN_COMPILER_IS(MSVC) +#define DAWN_ASSERT_LOOP_CONDITION (0, 0) +#else +#define DAWN_ASSERT_LOOP_CONDITION (0) +#endif + +// DAWN_ASSERT_CALLSITE_HELPER generates the actual assert code. In Debug it does what you would +// expect of an assert and in release it tries to give hints to make the compiler generate better +// code. +#if defined(DAWN_ENABLE_ASSERTS) + +#define DAWN_CHECK_CALLSITE_HELPER(file, func, line, condition) \ + do { \ + if (!(condition)) [[unlikely]] { \ + if (std::is_constant_evaluated()) { \ + ::dawn::XXXXXXXXXX_CheckFailedInConsteval_XXXXXXXXXX(); \ + } else { \ + ::dawn::HandleAssertionFailure(file, func, line, #condition); \ + abort(); \ + } \ + } \ + } while (DAWN_ASSERT_LOOP_CONDITION) + +#define DAWN_ASSERT_CALLSITE_HELPER(file, func, line, condition) \ + do { \ + if (!(condition)) [[unlikely]] { \ + if (std::is_constant_evaluated()) { \ + ::dawn::XXXXXXXXXX_CheckFailedInConsteval_XXXXXXXXXX(); \ + } else { \ + ::dawn::HandleAssertionFailure(file, func, line, #condition); \ + } \ + } \ + } while (DAWN_ASSERT_LOOP_CONDITION) + +#define DAWN_RELEASE_ASSUME_CALLSITE_HELPER(file, func, line, condition) \ + DAWN_ASSERT_CALLSITE_HELPER(file, func, line, condition) + +#else // defined(DAWN_ENABLE_ASSERTS) + +#define DAWN_CHECK_CALLSITE_HELPER(file, func, line, condition) \ + do { \ + if (!(condition)) [[unlikely]] { \ + abort(); \ + } \ + } while (DAWN_ASSERT_LOOP_CONDITION) + +#define DAWN_ASSERT_CALLSITE_HELPER(file, func, line, condition) \ + do { \ + static_assert(sizeof(!!(condition)) == sizeof(bool)); \ + } while (DAWN_ASSERT_LOOP_CONDITION) + +#if DAWN_COMPILER_IS(MSVC) +#define DAWN_RELEASE_ASSUME_CALLSITE_HELPER(file, func, line, condition) __assume(condition) +#elif DAWN_COMPILER_IS(CLANG) && __has_builtin(__builtin_assume) +#define DAWN_RELEASE_ASSUME_CALLSITE_HELPER(file, func, line, condition) \ + __builtin_assume(!!(condition)) +#else // DAWN_COMPILER_IS(*) +#define DAWN_RELEASE_ASSUME_CALLSITE_HELPER(file, func, line, condition) \ + DAWN_ASSERT_CALLSITE_HELPER(file, func, line, condition) +#endif // DAWN_COMPILER_IS(*) + +#endif // defined(DAWN_ENABLE_ASSERTS) + +// Release-mode assert (similar to Chromium CHECK). +// First does a debug-mode assert for a better debugging experience, then hard-aborts. +#define DAWN_CHECK(condition) DAWN_CHECK_CALLSITE_HELPER(__FILE__, __func__, __LINE__, condition) +// Asserts in debug if condition is not true (similar to Chromium DCHECK). +// In release this is a NOOP. (No longer calls assume compiler hint) +#define DAWN_ASSERT(condition) DAWN_ASSERT_CALLSITE_HELPER(__FILE__, __func__, __LINE__, condition) +// In release, this provides powerful optimization hints to the compiler. +// In debug, this is a DAWN_ASSERT. +#define DAWN_RELEASE_ASSUME(condition) \ + DAWN_RELEASE_ASSUME_CALLSITE_HELPER(__FILE__, __func__, __LINE__, condition) + +// Check-false (similar to Chromium NOTREACHED). +// This will hard-abort in both debug and release. +#define DAWN_UNREACHABLE() \ + do { \ + DAWN_CHECK(DAWN_ASSERT_LOOP_CONDITION && "Unreachable code hit"); \ + } while (DAWN_ASSERT_LOOP_CONDITION) + +namespace dawn { + +[[noreturn]] void HandleAssertionFailure(const char* file, + const char* function, + int line, + const char* condition); + +// This non-consteval function is invalid to call in consteval. If it's called, the compiler will +// print "note: declared here" pointing to this function so the reader knows what's going on. +inline void XXXXXXXXXX_CheckFailedInConsteval_XXXXXXXXXX() {} + +} // namespace dawn + +#endif // SRC_UTILS_ASSERT_H_ diff --git a/3rdparty/dawn/src/utils/compiler.h b/3rdparty/dawn/src/utils/compiler.h index bf11ec021..5766a64d4 100644 --- a/3rdparty/dawn/src/utils/compiler.h +++ b/3rdparty/dawn/src/utils/compiler.h @@ -72,15 +72,6 @@ #define DAWN_HAS_CPP_ATTRIBUTE(x) 0 #endif -// DAWN_BUILTIN_UNREACHABLE() -// -// Hints the compiler that a code path is unreachable. -#if DAWN_COMPILER_IS(MSVC) -#define DAWN_BUILTIN_UNREACHABLE() __assume(false) -#else -#define DAWN_BUILTIN_UNREACHABLE() __builtin_unreachable() -#endif - // DAWN_LIKELY(EXPR) // // Where available, hints the compiler that the expression will be true to help it generate code @@ -124,4 +115,143 @@ #define DAWN_NO_SANITIZE(instrumentation) #endif +// DAWN_TRIVIAL_ABI +// +// Marks a type as being eligible for the "trivial" ABI despite having a non-trivial destructor or +// copy/move constructor. Such types can be relocated after construction by simply copying their +// memory, which makes them eligible to be passed in registers. The canonical example is +// std::unique_ptr. +// +// Use with caution; this has some subtle effects on constructor/destructor ordering and will be +// very incorrect if the type relies on its address remaining constant. When used as a function +// argument (by value), the value may be constructed in the caller's stack frame, passed in a +// register, and then used and destructed in the callee's stack frame. A similar thing can occur +// when values are returned. +// +// TRIVIAL_ABI is not needed for types which have a trivial destructor and copy/move constructors, +// such as dawn::TypedInteger and other POD. +// +// It is also not likely to be effective on types too large to be passed in one or two registers on +// typical target ABIs. +// +// See also: +// https://clang.llvm.org/docs/AttributeReference.html#trivial-abi +// https://libcxx.llvm.org/docs/DesignDocs/UniquePtrTrivialAbi.html +#if DAWN_COMPILER_IS(CLANG) && DAWN_HAS_ATTRIBUTE(trivial_abi) +#define DAWN_TRIVIAL_ABI [[clang::trivial_abi]] +#else +#define DAWN_TRIVIAL_ABI +#endif + +// Annotates a function or class data member indicating it can lead to out-of-bounds accesses (OOB) +// if given incorrect inputs. +// +// For functions, this commonly includes functions which take pointers, sizes, iterators, sentinels, +// etc. and cannot fully check their preconditions (e.g. that the provided pointer actually points +// to an allocation of at least the provided size). Useful to diagnose potential misuse via +// `-Wunsafe-buffer-usage`, as well as to mark functions potentially in need of safer alternatives. +// +// For fields, this would be used to annotate both pointer and size fields that have not yet been +// converted to a span. +// +// All functions or fields annotated with this macro should come with a `// PRECONDITIONS: ` comment +// that explains what the caller must guarantee to ensure safe operation. Callers can then write +// `// SAFETY: ` comments explaining why the specific preconditions have been met. +// +// Ideally, unsafe functions should also be paired with a safer version, e.g. one that replaces +// pointer parameters with `span`s; otherwise, document safer replacement coding patterns callers +// can migrate to. +// +// Annotating a function `DAWN_UNSAFE_BUFFER_USAGE` means all call sites (that do not disable the +// warning) must wrap calls in `DAWN_UNSAFE_BUFFERS()`; see documentation there. Annotating a field +// `DAWN_UNSAFE_BUFFER_USAGE` means that `DAWN_UNSAFE_BUFFERS()` must wrap expressions that mutate +// of the field. +// +// See also: +// https://chromium.googlesource.com/chromium/src/+/main/docs/unsafe_buffers.md +// https://clang.llvm.org/docs/SafeBuffers.html +// https://clang.llvm.org/docs/DiagnosticsReference.html#wunsafe-buffer-usage +// +// Usage: +// ``` +// // Calls to this function must be wrapped in `DAWN_UNSAFE_BUFFERS()`. +// DAWN_UNSAFE_BUFFER_USAGE void Func(T* input, T* end); +// +// struct S { +// // Changing this pointer requires `DAWN_UNSAFE_BUFFERS()`. +// DAWN_UNSAFE_BUFFER_USAGE int* p; +// }; +// ``` +#if DAWN_HAS_CPP_ATTRIBUTE(clang::unsafe_buffer_usage) +#define DAWN_UNSAFE_BUFFER_USAGE [[clang::unsafe_buffer_usage]] +#else +#define DAWN_UNSAFE_BUFFER_USAGE +#endif + +// Annotates code indicating that it should be permanently exempted from `-Wunsafe-buffer-usage`. +// For temporary cases such as migrating callers to safer patterns, use `DAWN_UNSAFE_TODO()` +// instead; see documentation there. +// +// All calls to functions annotated with `DAWN_UNSAFE_BUFFER_USAGE` must be marked with one of these +// two macros; they can also be used around pointer arithmetic, pointer subscripting, and the like. +// +// ** USE OF THIS MACRO SHOULD BE VERY RARE.** Using this macro indicates that the compiler cannot +// verify that the code avoids OOB, and manual review is required. Even with manual review, it's +// easy for assumptions to change and security bugs to creep in over time. Prefer safer patterns +// instead. +// +// Usage should wrap the minimum necessary code, and *must* include a `// SAFETY: ...` comment that +// explains how the code guarantees safety or meets the requirements of called +// `DAWN_UNSAFE_BUFFER_USAGE` functions. Guarantees must be manually verifiable using only local +// invariants. Valid invariants include: +// - Runtime conditions or `CHECK()`s nearby +// - Invariants guaranteed by types in the surrounding code +// - Invariants guaranteed by function calls in the surrounding code +// - Caller requirements, if the containing function is itself annotated with +// `DAWN_UNSAFE_BUFFER_USAGE`; this is less safe and should be a last resort +// +// See also: +// https://chromium.googlesource.com/chromium/src/+/main/docs/unsafe_buffers.md +// https://clang.llvm.org/docs/SafeBuffers.html +// https://clang.llvm.org/docs/DiagnosticsReference.html#wunsafe-buffer-usage +// +// Usage: +// ``` +// // The following call will not trigger a compiler warning even if `Func()` +// // is annotated `DAWN_UNSAFE_BUFFER_USAGE`. +// return DAWN_UNSAFE_BUFFERS(Func(input, end)); +// ``` +// +// Test for `__clang__` directly, as there's no `__has_pragma` or similar (see +// https://github.com/llvm/llvm-project/issues/51887). +#if DAWN_COMPILER_IS(CLANG) +// Disabling `clang-format` allows each `_Pragma` to be on its own line, as recommended by +// https://gcc.gnu.org/onlinedocs/cpp/Pragmas.html. +// clang-format off +// SAFETY: This is the definition of the macro and not an unsafe usage. +#define DAWN_UNSAFE_BUFFERS(...) \ + _Pragma("clang unsafe_buffer_usage begin") \ + __VA_ARGS__ \ + _Pragma("clang unsafe_buffer_usage end") +// clang-format on +#else +// SAFETY: This is the definition of the macro and not an unsafe usage. +#define DAWN_UNSAFE_BUFFERS(...) __VA_ARGS__ +#endif + +// Annotates code indicating that it should be temporarily exempted from `-Wunsafe-buffer-usage`. +// While this is functionally the same as `DAWN_UNSAFE_BUFFERS()`, semantically it indicates that +// this is for migration purposes, and should be cleaned up as soon as possible. +// +// Usage: +// ``` +// // The following call will not trigger a compiler warning even if `Func()` +// // is annotated `DAWN_UNSAFE_BUFFER_USAGE`. +// return DAWN_UNSAFE_TODO(Func(input, end)); +// ``` +// SAFETY: The macro is used to tag code that should be modified to use DAWN_UNSAFE_BUFFERS or +// ideally use safer ways to manipulate the buffer. It's an explicit opt-out of DAWN_UNSAFE_BUFFERS +// and doesn't require a SAFETY argument when used. +#define DAWN_UNSAFE_TODO(...) DAWN_UNSAFE_BUFFERS(__VA_ARGS__) + #endif // SRC_UTILS_COMPILER_H_ diff --git a/3rdparty/dawn/src/utils/crash_handler.cc b/3rdparty/dawn/src/utils/crash_handler.cc new file mode 100644 index 000000000..4ab1ed9ed --- /dev/null +++ b/3rdparty/dawn/src/utils/crash_handler.cc @@ -0,0 +1,45 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/utils/crash_handler.h" + +#include "absl/debugging/failure_signal_handler.h" +#include "absl/debugging/symbolize.h" + +namespace dawn { + +void InstallCrashHandler(const char* argv0) { + absl::InitializeSymbolizer(argv0); + absl::FailureSignalHandlerOptions options; + options.symbolize_stacktrace = true; + options.use_alternate_stack = true; + options.alarm_on_failure_secs = 3; + options.call_previous_handler = true; + absl::InstallFailureSignalHandler(options); +} + +} // namespace dawn diff --git a/3rdparty/dawn/src/tint/lang/spirv/ir/literal_operand.cc b/3rdparty/dawn/src/utils/crash_handler.h similarity index 81% rename from 3rdparty/dawn/src/tint/lang/spirv/ir/literal_operand.cc rename to 3rdparty/dawn/src/utils/crash_handler.h index c691e340e..d2b7f4e05 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/ir/literal_operand.cc +++ b/3rdparty/dawn/src/utils/crash_handler.h @@ -1,4 +1,4 @@ -// Copyright 2023 The Dawn & Tint Authors +// Copyright 2026 The Dawn & Tint Authors // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -25,14 +25,14 @@ // 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. -#include "src/tint/lang/spirv/ir/literal_operand.h" +#ifndef SRC_UTILS_CRASH_HANDLER_H_ +#define SRC_UTILS_CRASH_HANDLER_H_ -TINT_INSTANTIATE_TYPEINFO(tint::spirv::ir::LiteralOperand); +namespace dawn { -namespace tint::spirv::ir { +// Install crash handler to print a demangled stack trace on unexpected crashes or assertions. +void InstallCrashHandler(const char* argv0); -LiteralOperand::LiteralOperand(const core::constant::Value* value) : Base(value) {} +} // namespace dawn -LiteralOperand::~LiteralOperand() = default; - -} // namespace tint::spirv::ir +#endif // SRC_UTILS_CRASH_HANDLER_H_ diff --git a/3rdparty/dawn/src/utils/force_crash.h b/3rdparty/dawn/src/utils/force_crash.h new file mode 100644 index 000000000..389faa0b2 --- /dev/null +++ b/3rdparty/dawn/src/utils/force_crash.h @@ -0,0 +1,74 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef UTILS_FORCE_CRASH_H_ +#define UTILS_FORCE_CRASH_H_ + +#include "src/utils/compiler.h" +#include "src/utils/platform.h" + +// DAWN_FORCE_CRASH() +// +// Immediately causes the program to terminate as fast as possible, at an address that's inside the +// function that used the macro, and with a signal that's different from a segfault. +#if DAWN_COMPILER_IS(CLANG) || DAWN_COMPILER_IS(GCC) +#if DAWN_PLATFORM_IS(X86) +#define DAWN_DETAIL_TRAP() asm volatile("int $3\n\t"); +#elif DAWN_PLATFORM_IS(ARM32) +#define DAWN_DETAIL_TRAP() asm volatile("bkpt 0"); +#elif DAWN_PLATFORM_IS(ARM64) +#define DAWN_DETAIL_TRAP() asm volatile("brk 0xf000"); +#elif DAWN_PLATFORM_IS(LOONGARCH) +#define DAWN_DETAIL_TRAP() asm volatile("break 0"); +#elif DAWN_PLATFORM_IS(RISCV) +#define DAWN_DETAIL_TRAP() asm volatile("ebreak"); +#elif DAWN_PLATFORM_IS(MIPS) +#define DAWN_DETAIL_TRAP() asm volatile("break"); +#elif DAWN_PLATFORM_IS(S390) || DAWN_PLATFORM_IS(S390X) +#define DAWN_DETAIL_TRAP() asm volatile(".word 0x0001"); +#elif DAWN_PLATFORM_IS(PPC) || DAWN_PLATFORM_IS(PPC64) +#define DAWN_DETAIL_TRAP() asm volatile("twge 2,2"); +#elif DAWN_PLATFORM_IS(WASM32) || DAWN_PLATFORM_IS(WASM64) +#define DAWN_DETAIL_TRAP() EM_ASM(debugger;); +#else +#error "Unsupported platform" +#endif + +#define DAWN_FORCE_CRASH() \ + do { \ + DAWN_DETAIL_TRAP(); \ + __builtin_unreachable(); \ + } while (false) + +#elif DAWN_COMPILER_IS(MSVC) +#define DAWN_FORCE_CRASH() __debugbreak() + +#else +#error "Unsupported compiler" +#endif + +#endif // UTILS_FORCE_CRASH_H_ diff --git a/3rdparty/dawn/src/utils/log.cc b/3rdparty/dawn/src/utils/log.cc new file mode 100644 index 000000000..e8f355bf5 --- /dev/null +++ b/3rdparty/dawn/src/utils/log.cc @@ -0,0 +1,162 @@ +// Copyright 2019 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/utils/log.h" + +#include +#include + +#include "src/utils/assert.h" +#include "src/utils/compiler.h" +#include "src/utils/platform.h" + +#if DAWN_PLATFORM_IS(ANDROID) +#include +#endif +#if DAWN_PLATFORM_IS(WINDOWS) +#include "src/utils/windows_with_undefs.h" +#endif + +namespace dawn { + +namespace { + +#if !defined(DAWN_DISABLE_LOGGING) +const char* SeverityName(LogSeverity severity) { + switch (severity) { + case LogSeverity::Debug: + return "Debug"; + case LogSeverity::Info: + return "Info"; + case LogSeverity::Warning: + return "Warning"; + case LogSeverity::Error: + return "Error"; + default: + DAWN_UNREACHABLE(); + return ""; + } +} +#endif + +#if DAWN_PLATFORM_IS(ANDROID) && !defined(DAWN_DISABLE_LOGGING) +android_LogPriority AndroidLogPriority(LogSeverity severity) { + switch (severity) { + case LogSeverity::Debug: + return ANDROID_LOG_INFO; + case LogSeverity::Info: + return ANDROID_LOG_INFO; + case LogSeverity::Warning: + return ANDROID_LOG_WARN; + case LogSeverity::Error: + return ANDROID_LOG_ERROR; + default: + DAWN_UNREACHABLE(); + return ANDROID_LOG_ERROR; + } +} +#endif // DAWN_PLATFORM_IS(ANDROID) && !defined(DAWN_DISABLE_LOGGING) + +} // anonymous namespace + +LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {} + +LogMessage::LogMessage(LogMessage&& other) = default; + +LogMessage& LogMessage::operator=(LogMessage&& other) = default; + +#if defined(DAWN_DISABLE_LOGGING) +LogMessage::~LogMessage() { + (void)mSeverity; + // Don't print logs to make fuzzing more efficient. Implemented as + // an early return to avoid warnings about unused member variables. + return; +} +#else // defined(DAWN_DISABLE_LOGGING) +LogMessage::~LogMessage() { + std::string fullMessage = mStream.str(); + + // If this message has been moved, its stream is empty. + if (fullMessage.empty()) { + return; + } + + const char* severityName = SeverityName(mSeverity); + +#if DAWN_PLATFORM_IS(ANDROID) + android_LogPriority androidPriority = AndroidLogPriority(mSeverity); + __android_log_print(androidPriority, "Dawn", "%s: %s\n", severityName, fullMessage.c_str()); +#else // DAWN_PLATFORM_IS(ANDROID) + FILE* outputStream = stdout; + if (mSeverity == LogSeverity::Warning || mSeverity == LogSeverity::Error) { + outputStream = stderr; + } + +#if DAWN_PLATFORM_IS(WINDOWS) && defined(OFFICIAL_BUILD) + // If we are in a sandboxed process on an official build, the stdout/stderr + // handles are likely not set, so trying to log to them will crash. + HANDLE handle; + if (outputStream == stderr) { + handle = GetStdHandle(STD_ERROR_HANDLE); + } else { + handle = GetStdHandle(STD_OUTPUT_HANDLE); + } + if (handle == INVALID_HANDLE_VALUE) { + return; + } +#endif // DAWN_PLATFORM_IS(WINDOWS) && defined(OFFICIAL_BUILD) + + // Note: we use fprintf because includes static initializers. + DAWN_UNSAFE_TODO(fprintf(outputStream, "%s: %s\n", severityName, fullMessage.c_str())); + fflush(outputStream); +#endif // DAWN_PLATFORM_IS(ANDROID) +} +#endif // defined(DAWN_DISABLE_LOGGING) + +LogMessage DebugLog() { + return LogMessage(LogSeverity::Debug); +} + +LogMessage InfoLog() { + return LogMessage(LogSeverity::Info); +} + +LogMessage WarningLog() { + return LogMessage(LogSeverity::Warning); +} + +LogMessage ErrorLog() { + return LogMessage(LogSeverity::Error); +} + +LogMessage DebugLog(const char* file, const char* function, int line) { + LogMessage message = DebugLog(); + message << file << ":" << line << "(" << function << ")"; + return message; +} + +} // namespace dawn diff --git a/3rdparty/dawn/src/utils/log.h b/3rdparty/dawn/src/utils/log.h new file mode 100644 index 000000000..cab4ad185 --- /dev/null +++ b/3rdparty/dawn/src/utils/log.h @@ -0,0 +1,108 @@ +// Copyright 2019 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_UTILS_LOG_H_ +#define SRC_UTILS_LOG_H_ + +// Dawn targets shouldn't use iostream or printf directly for several reasons: +// - iostream adds static initializers which we want to avoid. +// - printf and iostream don't show up in logcat on Android so printf debugging doesn't work but +// log-message debugging does. +// - log severity helps provide intent compared to a printf. +// +// Logging should in general be avoided: errors should go through the regular WebGPU error reporting +// mechanism and others form of logging should (TODO: eventually) go through the logging dependency +// injection, so for example they show up in Chromium's about:gpu page. Nonetheless there are some +// cases where logging is necessary and when this file was first introduced we needed to replace all +// uses of iostream so we could see them in Android's logcat. +// +// Regular logging is done using the [Debug|Info|Warning|Error]Log() function this way: +// +// InfoLog() << things << that << ostringstream << supports; // No need for a std::endl or "\n" +// +// It creates a LogMessage object that isn't stored anywhere and gets its destructor called +// immediately which outputs the stored ostringstream in the right place. +// +// This file also contains DAWN_DEBUG for "printf debugging" which works on Android and +// additionally outputs the file, line and function name. Use it this way: +// +// // Pepper this throughout code to get a log of the execution +// DAWN_DEBUG(); +// +// // Get more information +// DAWN_DEBUG() << texture.GetFormat(); + +#include + +namespace dawn { + +// Log levels mostly used to signal intent where the log message is produced and used to route +// the message to the correct output. +enum class LogSeverity { + Debug, + Info, + Warning, + Error, +}; + +// Essentially an ostringstream that will print itself in its destructor. +class LogMessage { + public: + explicit LogMessage(LogSeverity severity); + ~LogMessage(); + + LogMessage(LogMessage&& other); + LogMessage& operator=(LogMessage&& other); + + template + LogMessage& operator<<(T&& value) { + mStream << value; + return *this; + } + + private: + LogMessage(const LogMessage& other) = delete; + LogMessage& operator=(const LogMessage& other) = delete; + + LogSeverity mSeverity; + std::ostringstream mStream; +}; + +// Short-hands to create a LogMessage with the respective severity. +LogMessage DebugLog(); +LogMessage InfoLog(); +LogMessage WarningLog(); +LogMessage ErrorLog(); + +// DAWN_DEBUG is a helper macro that creates a DebugLog and outputs file/line/function +// information +LogMessage DebugLog(const char* file, const char* function, int line); +#define DAWN_DEBUG() ::dawn::DebugLog(__FILE__, __func__, __LINE__) + +} // namespace dawn + +#endif // SRC_UTILS_LOG_H_ diff --git a/3rdparty/dawn/src/tint/lang/spirv/ir/literal_operand.h b/3rdparty/dawn/src/utils/non_copyable.h similarity index 67% rename from 3rdparty/dawn/src/tint/lang/spirv/ir/literal_operand.h rename to 3rdparty/dawn/src/utils/non_copyable.h index c5275caef..6ddb98b5d 100644 --- a/3rdparty/dawn/src/tint/lang/spirv/ir/literal_operand.h +++ b/3rdparty/dawn/src/utils/non_copyable.h @@ -1,4 +1,4 @@ -// Copyright 2023 The Dawn & Tint Authors +// Copyright 2021 The Dawn & Tint Authors // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -25,25 +25,26 @@ // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -#ifndef SRC_TINT_LANG_SPIRV_IR_LITERAL_OPERAND_H_ -#define SRC_TINT_LANG_SPIRV_IR_LITERAL_OPERAND_H_ +#ifndef SRC_UTILS_NON_COPYABLE_H_ +#define SRC_UTILS_NON_COPYABLE_H_ -#include "src/tint/lang/core/ir/constant.h" -#include "src/tint/utils/rtti/castable.h" +namespace dawn { -namespace tint::spirv::ir { - -/// LiteralOperand is a type of constant value that is intended to be emitted as a literal in -/// the SPIR-V instruction stream. -class LiteralOperand final : public Castable { +// A base class to make a class non-copyable. +class NonCopyable { public: - /// Constructor - /// @param value the operand value - explicit LiteralOperand(const core::constant::Value* value); - /// Destructor - ~LiteralOperand() override; + constexpr NonCopyable() = default; + ~NonCopyable() = default; + + protected: + NonCopyable(NonCopyable&&) = default; + NonCopyable& operator=(NonCopyable&&) = default; + + private: + NonCopyable(const NonCopyable&) = delete; + void operator=(const NonCopyable&) = delete; }; -} // namespace tint::spirv::ir +} // namespace dawn -#endif // SRC_TINT_LANG_SPIRV_IR_LITERAL_OPERAND_H_ +#endif // SRC_UTILS_NON_COPYABLE_H_ diff --git a/3rdparty/dawn/src/tint/lang/core/ir/bitcast.cc b/3rdparty/dawn/src/utils/non_movable.h similarity index 69% rename from 3rdparty/dawn/src/tint/lang/core/ir/bitcast.cc rename to 3rdparty/dawn/src/utils/non_movable.h index ad8cad6d2..b5e2613f8 100644 --- a/3rdparty/dawn/src/tint/lang/core/ir/bitcast.cc +++ b/3rdparty/dawn/src/utils/non_movable.h @@ -1,4 +1,4 @@ -// Copyright 2023 The Dawn & Tint Authors +// Copyright 2024 The Dawn & Tint Authors // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: @@ -25,28 +25,24 @@ // 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. -#include "src/tint/lang/core/ir/bitcast.h" +#ifndef SRC_UTILS_NON_MOVABLE_H_ +#define SRC_UTILS_NON_MOVABLE_H_ -#include "src/tint/lang/core/ir/clone_context.h" -#include "src/tint/lang/core/ir/module.h" +#include "src/utils/non_copyable.h" -TINT_INSTANTIATE_TYPEINFO(tint::core::ir::Bitcast); +namespace dawn { -namespace tint::core::ir { +// A base class to make a class non-movable. +class NonMovable : NonCopyable { + protected: + constexpr NonMovable() = default; + ~NonMovable() = default; -Bitcast::Bitcast(Id id) : Base(id) {} + private: + NonMovable(NonMovable&&) = delete; + void operator=(NonMovable&&) = delete; +}; -Bitcast::Bitcast(Id id, InstructionResult* result, Value* val) : Base(id) { - AddOperand(Bitcast::kValueOperandOffset, val); - AddResult(result); -} +} // namespace dawn -Bitcast::~Bitcast() = default; - -Bitcast* Bitcast::Clone(CloneContext& ctx) { - auto* new_result = ctx.Clone(Result()); - auto* val = ctx.Remap(Val()); - return ctx.ir.CreateInstruction(new_result, val); -} - -} // namespace tint::core::ir +#endif // SRC_UTILS_NON_MOVABLE_H_ diff --git a/3rdparty/dawn/src/utils/numeric.h b/3rdparty/dawn/src/utils/numeric.h index a0015fa6b..bfe9696c8 100644 --- a/3rdparty/dawn/src/utils/numeric.h +++ b/3rdparty/dawn/src/utils/numeric.h @@ -30,8 +30,46 @@ #include #include +#include + +#include "src/utils/assert.h" +#include "src/utils/underlying_type.h" namespace dawn { + +// Checked conversion between differently sized integer-likes (i.e. all the types that can be used +// by ityp: integers, TypedIntegers, and enum classes). This is only defined for unsigned types +// because that is all that is needed at the time of writing, however eventually we will want to use +// this more widely, and we'll need to upgrade it (and the tests) to allow signed types. +template +constexpr inline Dst checked_cast(const Src& value) { + using ISrc = UnderlyingType; + using IDst = UnderlyingType; + // The compiler seems to be able to optimize away this CHECK, for Src/Dst pairs that can never + // fail (verified in Compiler Explorer with plain integers and enum classes). + // + // Note, we choose not to disallow checked_cast for casts that are always safe, even though that + // would guide authors toward static_casts that are statically-guaranteed safe. This is because + // when used with things like size_t, which one you would need to use could differ by bitness. + ISrc valueISrc = static_cast(value); + DAWN_CHECK(std::in_range(valueISrc)); + return Dst{static_cast(valueISrc)}; +} + +template +constexpr inline Dst dchecked_cast(const Src& value) { + using ISrc = UnderlyingType; + using IDst = UnderlyingType; + ISrc valueISrc = static_cast(value); + DAWN_ASSERT(std::in_range(valueISrc)); + return Dst{static_cast(valueISrc)}; +} + +template +constexpr inline bool kIsCastAlwaysInRange = + std::in_range(std::numeric_limits::lowest()) && + std::in_range(std::numeric_limits::max()); + template bool inline IsDoubleValueRepresentable(double value) { if constexpr (std::is_same_v || std::is_integral_v) { @@ -51,6 +89,7 @@ inline bool IsDoubleValueRepresentableAsF16(double value) { constexpr double kMaxF16 = 65504.0; return kLowestF16 <= value && value <= kMaxF16; } + } // namespace dawn #endif // SRC_UTILS_NUMERIC_H_ diff --git a/3rdparty/dawn/src/utils/numeric_nocompile.nc b/3rdparty/dawn/src/utils/numeric_nocompile.nc new file mode 100644 index 000000000..56b0fd6e3 --- /dev/null +++ b/3rdparty/dawn/src/utils/numeric_nocompile.nc @@ -0,0 +1,55 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "src/utils/numeric.h" + +namespace dawn { + +void TestIsDoubleValueRepresentable() { + (void) IsDoubleValueRepresentable(0.0); // expected-error-re@numeric.h:* {{static assertion failed due to requirement '{{.*}}': Unsupported type}} +} + +// Tests for checked_cast +void TestCheckedCast() { + { [[maybe_unused]] constexpr uint32_t x = checked_cast(uint64_t{0x0'FFFF'FFFF}); } + { [[maybe_unused]] constexpr uint32_t x = checked_cast(uint64_t{0x1'0000'0000}); } // expected-error {{must be initialized by a constant expression}} + { [[maybe_unused]] constexpr uint32_t x = checked_cast(int16_t{-1}); } // expected-error {{must be initialized by a constant expression}} + + { [[maybe_unused]] constexpr uint32_t x = checked_cast(int64_t{0x0'FFFF'FFFF}); } + { [[maybe_unused]] constexpr uint32_t x = checked_cast(int64_t{0x1'0000'0000}); } // expected-error {{must be initialized by a constant expression}} +} + +// Basic test for dchecked_cast +void TestDcheckedCast() { +#ifdef DAWN_ENABLE_ASSERTS + { [[maybe_unused]] constexpr uint32_t x = dchecked_cast(int32_t{-1}); } // expected-error {{must be initialized by a constant expression}} +#else + { [[maybe_unused]] constexpr uint32_t x = dchecked_cast(int32_t{-1}); } +#endif +} + +} diff --git a/3rdparty/dawn/src/utils/platform.h b/3rdparty/dawn/src/utils/platform.h new file mode 100644 index 000000000..4dd58a487 --- /dev/null +++ b/3rdparty/dawn/src/utils/platform.h @@ -0,0 +1,323 @@ +// Copyright 2017 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_UTILS_PLATFORM_H_ +#define SRC_UTILS_PLATFORM_H_ + +// Use #if DAWN_PLATFORM_IS(X) for platform specific code. +// Do not use #ifdef or the naked macro DAWN_PLATFORM_IS_X. +// This can help avoid common mistakes like not including "Platform.h" and falling into unwanted +// code block as usage of undefined macro "function" will be blocked by the compiler. +#define DAWN_PLATFORM_IS(X) (1 == DAWN_PLATFORM_IS_##X) + +// Define platform macros for OSes: +// +// - WINDOWS +// - WIN32 +// - WINUWP +// - POSIX +// - LINUX +// - ANDROID +// - CHROMEOS +// - APPLE +// - IOS +// - TVOS +// - MACOS +// - FUCHSIA +// - EMSCRIPTEN +#if defined(_WIN32) || defined(_WIN64) +#include +#define DAWN_PLATFORM_IS_WINDOWS 1 +#if WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP +#define DAWN_PLATFORM_IS_WIN32 1 +#elif WINAPI_FAMILY == WINAPI_FAMILY_PC_APP +#define DAWN_PLATFORM_IS_WINUWP 1 +#else +#error "Unsupported Windows platform." +#endif + +#elif defined(__linux__) +#define DAWN_PLATFORM_IS_LINUX 1 +#define DAWN_PLATFORM_IS_POSIX 1 +#if defined(__ANDROID__) +#define DAWN_PLATFORM_IS_ANDROID 1 +#elif defined(DAWN_OS_CHROMEOS) +#define DAWN_PLATFORM_IS_CHROMEOS 1 +#else +#define DAWN_PLATFORM_IS_LINUX_DESKTOP 1 +#endif + +#elif defined(__APPLE__) +#define DAWN_PLATFORM_IS_APPLE 1 +#define DAWN_PLATFORM_IS_POSIX 1 +#include +#if TARGET_OS_IPHONE +#define DAWN_PLATFORM_IS_IOS 1 +#if TARGET_OS_TV +#define DAWN_PLATFORM_IS_TVOS 1 +#endif +#elif TARGET_OS_MAC +#define DAWN_PLATFORM_IS_MACOS 1 +#else +#error "Unsupported Apple platform." +#endif + +#elif defined(__Fuchsia__) +#define DAWN_PLATFORM_IS_FUCHSIA 1 +#define DAWN_PLATFORM_IS_POSIX 1 + +#elif defined(__EMSCRIPTEN__) +#define DAWN_PLATFORM_IS_EMSCRIPTEN 1 +#define DAWN_PLATFORM_IS_POSIX 1 +#include + +#else +#error "Unsupported platform." +#endif + +// Define platform macros for CPU architectures: +// +// - X86 +// - I386 +// - X86_64 +// - ARM +// - ARM32 +// - ARM64 +// - LOONGARCH +// - LOONGARCH32 +// - LOONGARCH64 +// - RISCV +// - RISCV32 +// - RISCV64 +// - MIPS +// - MIPS32 +// - MIPS64 +// - S390 +// - S390X +// - PPC +// - PPC64 +#if defined(__i386__) || defined(_M_IX86) +#define DAWN_PLATFORM_IS_X86 1 +#define DAWN_PLATFORM_IS_I386 1 +#elif defined(__x86_64__) || defined(_M_X64) +#define DAWN_PLATFORM_IS_X86 1 +#define DAWN_PLATFORM_IS_X86_64 1 + +#elif defined(__arm__) || defined(_M_ARM) +#define DAWN_PLATFORM_IS_ARM 1 +#define DAWN_PLATFORM_IS_ARM32 1 +#elif defined(__aarch64__) || defined(_M_ARM64) +#define DAWN_PLATFORM_IS_ARM 1 +#define DAWN_PLATFORM_IS_ARM64 1 + +#elif defined(__loongarch__) +#define DAWN_PLATFORM_IS_LOONGARCH 1 +#if __loongarch_grlen == 64 +#define DAWN_PLATFORM_IS_LOONGARCH64 1 +#else +#define DAWN_PLATFORM_IS_LOONGARCH32 1 +#endif + +#elif defined(__riscv) +#define DAWN_PLATFORM_IS_RISCV 1 +#if __riscv_xlen == 32 +#define DAWN_PLATFORM_IS_RISCV32 1 +#else +#define DAWN_PLATFORM_IS_RISCV64 1 +#endif + +#elif defined(__mips__) +#define DAWN_PLATFORM_IS_MIPS 1 +#if _MIPS_SIM == _ABIO32 +#define DAWN_PLATFORM_IS_MIPS32 1 +#else +#define DAWN_PLATFORM_IS_MIPS64 1 +#endif + +#elif defined(__s390__) +#define DAWN_PLATFORM_IS_S390 1 +#elif defined(__s390x__) +#define DAWN_PLATFORM_IS_S390X 1 + +#elif defined(__PPC__) +#define DAWN_PLATFORM_IS_PPC 1 +#elif defined(__PPC64__) +#define DAWN_PLATFORM_IS_PPC64 1 + +#elif defined(__wasm32__) +#define DAWN_PLATFORM_IS_WASM32 1 +#elif defined(__wasm64__) +#define DAWN_PLATFORM_IS_WASM64 1 + +#else +#error "Unsupported platform." +#endif + +// Define platform macros for pointer width: +// +// - 64_BIT +// - 32_BIT +#if defined(DAWN_PLATFORM_IS_X86_64) || defined(DAWN_PLATFORM_IS_ARM64) || \ + defined(DAWN_PLATFORM_IS_RISCV64) || defined(DAWN_PLATFORM_IS_MIPS64) || \ + defined(DAWN_PLATFORM_IS_S390X) || defined(DAWN_PLATFORM_IS_PPC64) || \ + defined(DAWN_PLATFORM_IS_LOONGARCH64) || defined(DAWN_PLATFORM_IS_WASM64) +#define DAWN_PLATFORM_IS_64_BIT 1 +static_assert(sizeof(sizeof(char)) == 8, "Expect sizeof(size_t) == 8"); +#elif defined(DAWN_PLATFORM_IS_I386) || defined(DAWN_PLATFORM_IS_ARM32) || \ + defined(DAWN_PLATFORM_IS_RISCV32) || defined(DAWN_PLATFORM_IS_MIPS32) || \ + defined(DAWN_PLATFORM_IS_S390) || defined(DAWN_PLATFORM_IS_PPC32) || \ + defined(DAWN_PLATFORM_IS_LOONGARCH32) || defined(DAWN_PLATFORM_IS_WASM32) +#define DAWN_PLATFORM_IS_32_BIT 1 +static_assert(sizeof(sizeof(char)) == 4, "Expect sizeof(size_t) == 4"); +#else +#error "Unsupported platform" +#endif + +// This section define other platform macros to 0 to avoid undefined macro usage error. +#if !defined(DAWN_PLATFORM_IS_WINDOWS) +#define DAWN_PLATFORM_IS_WINDOWS 0 +#endif +#if !defined(DAWN_PLATFORM_IS_WIN32) +#define DAWN_PLATFORM_IS_WIN32 0 +#endif +#if !defined(DAWN_PLATFORM_IS_WINUWP) +#define DAWN_PLATFORM_IS_WINUWP 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_POSIX) +#define DAWN_PLATFORM_IS_POSIX 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_LINUX) +#define DAWN_PLATFORM_IS_LINUX 0 +#endif +#if !defined(DAWN_PLATFORM_IS_ANDROID) +#define DAWN_PLATFORM_IS_ANDROID 0 +#endif +#if !defined(DAWN_PLATFORM_IS_CHROMEOS) +#define DAWN_PLATFORM_IS_CHROMEOS 0 +#endif +#if !defined(DAWN_PLATFORM_IS_LINUX_DESKTOP) +#define DAWN_PLATFORM_IS_LINUX_DESKTOP 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_APPLE) +#define DAWN_PLATFORM_IS_APPLE 0 +#endif +#if !defined(DAWN_PLATFORM_IS_IOS) +#define DAWN_PLATFORM_IS_IOS 0 +#endif +#if !defined(DAWN_PLATFORM_IS_MACOS) +#define DAWN_PLATFORM_IS_MACOS 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_FUCHSIA) +#define DAWN_PLATFORM_IS_FUCHSIA 0 +#endif +#if !defined(DAWN_PLATFORM_IS_EMSCRIPTEN) +#define DAWN_PLATFORM_IS_EMSCRIPTEN 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_X86) +#define DAWN_PLATFORM_IS_X86 0 +#endif +#if !defined(DAWN_PLATFORM_IS_I386) +#define DAWN_PLATFORM_IS_I386 0 +#endif +#if !defined(DAWN_PLATFORM_IS_X86_64) +#define DAWN_PLATFORM_IS_X86_64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_ARM) +#define DAWN_PLATFORM_IS_ARM 0 +#endif +#if !defined(DAWN_PLATFORM_IS_ARM32) +#define DAWN_PLATFORM_IS_ARM32 0 +#endif +#if !defined(DAWN_PLATFORM_IS_ARM64) +#define DAWN_PLATFORM_IS_ARM64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_LOONGARCH) +#define DAWN_PLATFORM_IS_LOONGARCH 0 +#endif +#if !defined(DAWN_PLATFORM_IS_LOONGARCH32) +#define DAWN_PLATFORM_IS_LOONGARCH32 0 +#endif +#if !defined(DAWN_PLATFORM_IS_LOONGARCH64) +#define DAWN_PLATFORM_IS_LOONGARCH64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_RISCV) +#define DAWN_PLATFORM_IS_RISCV 0 +#endif +#if !defined(DAWN_PLATFORM_IS_RISCV32) +#define DAWN_PLATFORM_IS_RISCV32 0 +#endif +#if !defined(DAWN_PLATFORM_IS_RISCV64) +#define DAWN_PLATFORM_IS_RISCV64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_MIPS) +#define DAWN_PLATFORM_IS_MIPS 0 +#endif +#if !defined(DAWN_PLATFORM_IS_MIPS32) +#define DAWN_PLATFORM_IS_MIPS32 0 +#endif +#if !defined(DAWN_PLATFORM_IS_MIPS64) +#define DAWN_PLATFORM_IS_MIPS64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_S390) +#define DAWN_PLATFORM_IS_S390 0 +#endif +#if !defined(DAWN_PLATFORM_IS_S390X) +#define DAWN_PLATFORM_IS_S390X 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_PPC) +#define DAWN_PLATFORM_IS_PPC 0 +#endif +#if !defined(DAWN_PLATFORM_IS_PPC64) +#define DAWN_PLATFORM_IS_PPC64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_WASM32) +#define DAWN_PLATFORM_IS_WASM32 0 +#endif +#if !defined(DAWN_PLATFORM_IS_WASM64) +#define DAWN_PLATFORM_IS_WASM64 0 +#endif + +#if !defined(DAWN_PLATFORM_IS_64_BIT) +#define DAWN_PLATFORM_IS_64_BIT 0 +#endif +#if !defined(DAWN_PLATFORM_IS_32_BIT) +#define DAWN_PLATFORM_IS_32_BIT 0 +#endif + +#endif // SRC_UTILS_PLATFORM_H_ diff --git a/3rdparty/dawn/src/utils/span.h b/3rdparty/dawn/src/utils/span.h new file mode 100644 index 000000000..90b7f7c39 --- /dev/null +++ b/3rdparty/dawn/src/utils/span.h @@ -0,0 +1,295 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_UTILS_SPAN_H_ +#define SRC_UTILS_SPAN_H_ + +#include +#include +#include +#include + +#include "src/utils/numeric.h" +#include "src/utils/underlying_type.h" + +namespace dawn { + +// A span is a contiguous view of elements that can be accessed like an array. They are preferred +// over pointers and sizes because they enforce safe usage (in addition to requiring less typing). +// Dawn has its own Span class for multiple reasons: +// +// - It needs a version of std::span that can work with TypedInteger to make it impossible to use a +// span with the wrong kind of index. +// - It needs a version of std::span with a configurable type for the pointer, so that it can be +// changed to a raw_ptr when the span is stored as a member (this is important to keep the +// MiraclePtr refcount exact). +// - It ensures that the layout of Span is exactly (size_t mSize, T* mData) to match webgpu.h +// structures where the count of elements always comes just before the pointer to the elements. +// This is important because conversions between webgpu.h and dawn_platform.h structures is done +// by simply casting the pointer (and checking that the layout matches). dawn_platform.h +// structures use Span so we need to know the exact layout. +// +// The deviations from std::span are marked with DIFF. + +namespace detail { +template +class SpanBase; +} + +// A direct replacement for std::span +template +using Span = detail::SpanBase; + +namespace ityp { +// A replacement for std::span but with a different index type (like a TypedInteger). +template +using span = dawn::detail::SpanBase; +} // namespace ityp + +// The equivalent of std::dynamic_extent for the given index type. +template +inline constexpr Index DynamicExtent = std::numeric_limits::max(); + +namespace detail { + +template +concept LegalDataConversion = std::is_convertible_v; + +template +concept CompatibleIter = std::contiguous_iterator && + LegalDataConversion>, T>; + +template +concept CompatibleRange = requires(R r) { + { r.data() } -> std::convertible_to; + { r.size() } -> std::same_as; +}; + +// DIFF: only dynamic_extent is supported at the moment because Dawn might not need spans with +// static extents. +// DIFF: size_t in function signatures is replaced by Index to support typed integers as the index +// type. The only exception is size_bytes(). +template +class SpanBase { + private: + using Self = SpanBase; + + public: + // Type aliases and static members. + + // DIFF: size_type / difference_type missing because it's not clear what they should be, Index + // or size_t? + // DIFF: const_iterator missing to match LLVM's libc++ + // DIFF: [const_]reverse_iterator missing to avoid including until it is needed. + using element_type = T; + using value_type = std::remove_cv::type; + using pointer = T*; + using const_pointer = const T*; + using reference = T&; + using const_reference = const T&; + using iterator = std::span::iterator; + + static inline constexpr Index extent = DynamicExtent; + + // Constructors + // DIFF: The constructor from a C-style array is not present. + // DIFF: Many constructors are UNSAFE_BUFFER_USAGE. + // DIFF: The constructor from a range is less strict than the spec requires as it would be + // challenging to duplicate the exact logic while keeping support for custom index types. + + constexpr SpanBase() noexcept = default; + + // Constructor from a pointer + size. This is UNSAFE_BUFFER_USAGE as other methods should be + // preferred to create spans directly from ranges. Will DAWN_CHECK() if the size doesn't fit in + // a size_t. + template + requires CompatibleIter + DAWN_UNSAFE_BUFFER_USAGE constexpr SpanBase(It first, Index count) + : mSize(checked_cast(count)), mData(std::to_address(first)) { + DAWN_CHECK(count != DynamicExtent); + } + + // Constructor from two iterators, this is UNSAFE_BUFFER_USAGE as other method should be + // preferred to create spans directly from ranges. Will DAWN_CHECK() if the size doesn't fit in + // a size_t. + template + requires(CompatibleIter && std::sized_sentinel_for && + !std::is_convertible_v) + DAWN_UNSAFE_BUFFER_USAGE constexpr SpanBase(It first, End last) + : mSize(last - first), mData(std::to_address(first)) { + DAWN_CHECK(first <= last); + if constexpr (sizeof(size_t) > sizeof(Index)) { + DAWN_CHECK(mSize <= size_t{UnderlyingType{DynamicExtent}}); + } + } + + // Constructor from a "range-like" that provides `T* data()` and `Index size()`. Note that this + // is quite different from Chromium's base::span constructor from ranges because adapting that + // constructor to support TypedInteger for Index would be extremely challenging. Will + // DAWN_CHECK() if the size doesn't fit in a size_t. + template + requires CompatibleRange + // NOLINTNEXTLINE(runtime/explicit) + constexpr SpanBase(R&& range) + : mSize(checked_cast(range.size())), mData(range.data()) {} + template + requires CompatibleRange && std::is_const_v + // NOLINTNEXTLINE(runtime/explicit) + constexpr SpanBase(const R& range) + : mSize(checked_cast(range.size())), mData(range.data()) {} + + // Move / copy constructor / assignment operator. + constexpr SpanBase(const SpanBase& other) noexcept = default; + constexpr SpanBase(SpanBase&& other) noexcept = default; + constexpr SpanBase& operator=(const SpanBase& other) noexcept = default; + constexpr SpanBase& operator=(SpanBase&& other) noexcept = default; + + // Iterators + // + // Note that iterators use the std::span iterators to take advantage of the hardened stdlib. + + // DIFF: cbegin/cend missing to match LLVM's libc++ + // DIFF: r[c]begin/end missing to avoid including until it is needed. + + constexpr iterator begin() const noexcept { return as_std_span().begin(); } + constexpr iterator end() const noexcept { return as_std_span().end(); } + + // Element access + + // Returns a reference to the first element of this. When empty, will DAWN_CHECK(). + constexpr reference front() const noexcept { return at(Index{0u}); } + // Returns a reference to the last element of this. When empty, will DAWN_CHECK(). + constexpr reference back() const noexcept { + // Note that an underflow happens in empty spans, which will make the argument to `at` be + // the maximum value and cause a DAWN_CHECK. + return at(size() - Index{1u}); + } + + // Returns a reference to the element of this at `index`. Will DAWN_CHECK() if OOB. + constexpr reference at(Index index) const { + DAWN_CHECK(index < size()); + // SAFETY: The argument to unchecked_at is already checked in range in the DAWN_CHECK above. + return DAWN_UNSAFE_BUFFERS(unchecked_at(index)); + } + // Returns a reference to the element of this at `index`. Will DAWN_CHECK() if OOB. + constexpr T& operator[](Index index) const noexcept { return at(index); } + + // Returns a pointer at the contents of this. + constexpr pointer data() const noexcept { return mData; } + + // Observers + + // Returns the number of elements of this. + constexpr Index size() const noexcept { + return Index(static_cast>(mSize)); + } + + // Returns the footprint in bytes of the elements of this. + constexpr size_t size_bytes() const noexcept { return mSize * sizeof(element_type); } + + // Returns true if this contains no elements. + [[nodiscard]] constexpr bool empty() const noexcept { return mSize == 0; } + + // Subviews + // DIFF: subviews with template Offset / Count missing. + // DIFF: dynamic_extent is not supported in the 2-arg version of subspan(), the single argument + // overload must be used instead. + + // Returns a span of the first `count` elements of this. Will DAWN_CHECK() if OOB. + constexpr Self first(Index count) const { + DAWN_CHECK(count <= size()); + // SAFETY: data() points at at least size() elements, so the DAWN_CHECK ensure that the + // result span is a subset of this + return DAWN_UNSAFE_BUFFERS(Self(data(), count)); + } + + // Returns a span of the last `count` elements of this. Will DAWN_CHECK() if OOB. + constexpr Self last(Index count) const { + DAWN_CHECK(count <= size()); + // SAFETY: data() points at at least size() elements, so the DAWN_CHECK ensure that the + // result span is a subset of this. The argument to unchecked_at is already checked in range + // in the DAWN_CHECK above. + return DAWN_UNSAFE_BUFFERS(Self(&unchecked_at(size() - count), count)); + } + + // Returns a span starting at `offset` and until the end of this. Will DAWN_CHECK() if OOB. + constexpr Self subspan(Index offset) const { + DAWN_CHECK(offset <= size()); + Index remainingSize = size() - offset; + // SAFETY: data() points at at least size() elements, so the DAWN_CHECK ensure that the + // result span is a subset of this. The argument to unchecked_at is already checked in range + // in the first DAWN_CHECK above. + return DAWN_UNSAFE_BUFFERS(Self(&unchecked_at(offset), remainingSize)); + } + // Returns a span starting at `offset` and of `count` elements inside of this. Will DAWN_CHECK() + // if OOB. + constexpr Self subspan(Index offset, Index count) const { + DAWN_CHECK(offset <= size()); + DAWN_CHECK(count <= size() - offset); + // SAFETY: data() points at at least size() elements, so the DAWN_CHECKs ensure that the + // result span is a subset of this. The argument to unchecked_at is already checked in range + // in the first DAWN_CHECK above. + return DAWN_UNSAFE_BUFFERS(Self(&unchecked_at(offset), count)); + } + + // Additions not part of std::span. + + // None for now, but consider adding the following like in Chromium's base::span: + // + // - constructor from (&T)[N] + // - operator ==, operator <=> + // - copy_from, copy_prefix_from + // - split_at, take_first, take_first_elem + // - get_at + // - to_fixed_extent + + private: + // Helper function used to avoid doing the DAWN_CHECK inside at() redundantly when the + // precondition is already checked by some other mean. + DAWN_UNSAFE_BUFFER_USAGE constexpr reference unchecked_at(Index typedIndex) const { + size_t index = checked_cast(typedIndex); + // SAFETY: The caller must guarantee that the index is in range already. + return DAWN_UNSAFE_BUFFERS(*(data() + index)); + } + + // Helper function to return the equivalent std::span. This is necessary to be able to use + // the hardened std::span iterators when the standard library enables them. + constexpr std::span as_std_span() const { + // SAFETY: This is the same allocation and size as this. + return DAWN_UNSAFE_BUFFERS({mData, mSize}); + } + + // Keep members in this order as it matches the layout of webgpu.h, see toplevel comment. + size_t mSize = 0; + PtrType mData = {}; +}; + +} // namespace detail + +} // namespace dawn + +#endif // SRC_UTILS_SPAN_H_ diff --git a/3rdparty/dawn/src/utils/span_nocompile.nc b/3rdparty/dawn/src/utils/span_nocompile.nc new file mode 100644 index 000000000..7e254e3ba --- /dev/null +++ b/3rdparty/dawn/src/utils/span_nocompile.nc @@ -0,0 +1,115 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Test the type checks of dawn::Span + +#include + +#include "src/utils/span.h" +#include "src/utils/typed_integer.h" + +namespace dawn { + +static constexpr std::array kSpanData = {1, 2, 3, 4, 5}; + +using Index = TypedInteger; +using IndexSizeT = TypedInteger; + +struct FakeRange { + size_t size() const { return kSpanData.size(); } + const int* data() const { return kSpanData.data(); } +}; + +struct FakeTypedRange { + Index size() const { + return Index{uint32_t{kSpanData.size()}}; + } + const int* data() const { return kSpanData.data(); } +}; + +void TestConstPointerToNonConstSpan() { + DAWN_UNSAFE_BUFFERS(Span(kSpanData.data(), kSpanData.size())); // Control case. + DAWN_UNSAFE_BUFFERS(Span(kSpanData.data(), kSpanData.size())); // expected-error {{no matching constructor for initialization}} + + DAWN_UNSAFE_BUFFERS(Span(kSpanData.begin(), kSpanData.end())); // Control case. + DAWN_UNSAFE_BUFFERS(Span(kSpanData.begin(), kSpanData.end())); // expected-error {{no matching constructor for initialization of}} + + Span{FakeRange()}; // Control case. + Span{FakeRange()}; // expected-error {{no matching constructor for initialization of}} +} + +void TestConstructorsThatRequireDawnUnsafeBuffers() { + DAWN_UNSAFE_BUFFERS(Span(kSpanData.data(), kSpanData.size())); // Control case. + // TODO(https://crbug.com/523128530): DAWN_UNSAFE_BUFFERS doesn't seem required in no-compile tests for some reason. Fix that and add an expected error here. + Span(kSpanData.data(), kSpanData.size()); + + DAWN_UNSAFE_BUFFERS(Span(kSpanData.begin(), kSpanData.end())); // Control case. + // TODO(https://crbug.com/523128530): DAWN_UNSAFE_BUFFERS doesn't seem required in no-compile tests for some reason. Fix that and add an expected error here. + Span(kSpanData.begin(), kSpanData.end()); +} + +void TestConstructorWithRangeRequirements() { + Span{FakeRange()}; // Control case. + + struct FakeRangeBadSize { + uint8_t size() const { + return uint8_t{kSpanData.size()}; + } + const int* data() const { return kSpanData.data(); } + }; + Span{FakeRangeBadSize()}; // expected-error {{no matching constructor for initialization of}} + + struct FakeRangeTypedSize { + IndexSizeT size() const { + return IndexSizeT{kSpanData.size()}; + } + const int* data() const { return kSpanData.data(); } + }; + Span{FakeRangeTypedSize()}; // expected-error {{no matching constructor for initialization of}} + + struct FakeRangeBadData { + size_t size() const { + return kSpanData.size(); + } + const int& data() const { return *kSpanData.data(); } + }; + Span{FakeRangeBadData()}; // expected-error {{no matching constructor for initialization of}} +} + +void TestTypedIntegerArguments() { + ityp::span sp{FakeTypedRange()}; + + DAWN_UNSAFE_BUFFERS(ityp::span(kSpanData.data(), kSpanData.size())); // expected-error {{no matching constructor for initialization}} + (void) sp.at(2); // expected-error {{no viable conversion from}} + (void) sp[2]; // expected-error {{no viable overloaded operator[]}} + (void) sp.first(2); // expected-error {{no viable conversion from}} + (void) sp.last(2); // expected-error {{no viable conversion from}} + (void) sp.subspan(2); // expected-error {{no matching member function for call to}} + (void) sp.subspan(2, 2); // expected-error {{no matching member function for call to}} +} + +} // namespace dawn diff --git a/3rdparty/dawn/src/utils/span_tests.cc b/3rdparty/dawn/src/utils/span_tests.cc new file mode 100644 index 000000000..733988d63 --- /dev/null +++ b/3rdparty/dawn/src/utils/span_tests.cc @@ -0,0 +1,601 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include + +#include + +#include "partition_alloc/pointers/raw_ptr.h" +#include "src/utils/span.h" +#include "src/utils/typed_integer.h" + +namespace dawn { +namespace { + +static constexpr std::array kSpanData = {1, 2, 3, 4, 5}; + +using Index = TypedInteger; +using Index8 = TypedInteger; +using Index64 = TypedInteger; + +struct FakeRange { + size_t size() const { return kSpanData.size(); } + const int* data() const { return kSpanData.data(); } +}; + +struct FakeTypedRange { + Index size() const { + return Index{uint32_t{kSpanData.size()}}; + } + const int* data() const { return kSpanData.data(); } +}; + +struct FakeTyped64Range { + Index64 size() const { + return Index64{uint64_t{kSpanData.size()}}; + } + const int* data() const { return kSpanData.data(); } +}; + +TEST(SpanTest, Constructor_Default) { + { + Span sp; + EXPECT_EQ(sp.size(), 0u); + EXPECT_EQ(sp.data(), nullptr); + } + { + ityp::span sp; + EXPECT_EQ(sp.size(), Index{0u}); + EXPECT_EQ(sp.data(), nullptr); + } +} + +TEST(SpanTest, Constructor_PointerAndSize) { + int data[] = {1, 2, 3}; + int constData[] = {1, 2, 3}; + raw_ptr rptr = data; + + // T* + size for Span + { + // SAFETY: Test for the unsafe constructor. + Span DAWN_UNSAFE_BUFFERS(sp{&data[0], 3}); + EXPECT_EQ(sp.size(), 3u); + EXPECT_EQ(sp.data(), data); + } + // const T* + size for Span + { + // SAFETY: Test for the unsafe constructor. + Span DAWN_UNSAFE_BUFFERS(sp{&constData[0], 3}); + EXPECT_EQ(sp.size(), 3u); + EXPECT_EQ(sp.data(), constData); + } + // T* + size for Span + { + // SAFETY: Test for the unsafe constructor. + Span DAWN_UNSAFE_BUFFERS(sp{&data[0], 3}); + EXPECT_EQ(sp.size(), 3u); + EXPECT_EQ(sp.data(), data); + } + + // T* + size for ityp::span + { + // SAFETY: Test for the unsafe constructor. + ityp::span DAWN_UNSAFE_BUFFERS(sp{&data[0], Index{3u}}); + EXPECT_EQ(sp.size(), Index{3u}); + EXPECT_EQ(sp.data(), data); + } + // const T* + size for ityp::span + { + // SAFETY: Test for the unsafe constructor. + ityp::span DAWN_UNSAFE_BUFFERS(sp{&constData[0], Index{3u}}); + EXPECT_EQ(sp.size(), Index{3u}); + EXPECT_EQ(sp.data(), constData); + } + // T* + size for ityp::span + { + // SAFETY: Test for the unsafe constructor. + ityp::span DAWN_UNSAFE_BUFFERS(sp{&data[0], Index{3u}}); + EXPECT_EQ(sp.size(), Index{3u}); + EXPECT_EQ(sp.data(), data); + } +} + +TEST(SpanDeathTest, Constructor_PointerAndSizeOversizedIndex) { + // These tests are only relevant on 32-bit builds. + if constexpr (sizeof(size_t) > sizeof(uint32_t)) { + GTEST_SKIP(); + } + + constexpr Index64 kHugeSize{0x1'0000'0000LLU}; + // SAFETY: Test for the unsafe constructor. + DAWN_UNSAFE_BUFFERS(EXPECT_DEATH_IF_SUPPORTED( + (ityp::span(kSpanData.data(), kHugeSize)), "")); +} + +TEST(SpanTest, Constructor_TwoIterators) { + std::array data = {1, 2, 3}; + const std::array constData = {1, 2, 3}; + + // 2 x iterator for Span + { + // SAFETY: Test for the unsafe constructor. + Span DAWN_UNSAFE_BUFFERS(sp{data.begin(), data.end()}); + EXPECT_EQ(sp.size(), 3u); + EXPECT_EQ(sp.data(), data.data()); + } + // 2 x const_iterator for Span + { + // SAFETY: Test for the unsafe constructor. + Span DAWN_UNSAFE_BUFFERS(sp{constData.begin(), constData.end()}); + EXPECT_EQ(sp.size(), 3u); + EXPECT_EQ(sp.data(), constData.data()); + } + // 2 x iterator for Span + { + // SAFETY: Test for the unsafe constructor. + Span DAWN_UNSAFE_BUFFERS(sp{data.begin(), data.end()}); + EXPECT_EQ(sp.size(), 3u); + EXPECT_EQ(sp.data(), data.data()); + } + + // 2 x iterator for ityp::span + { + // SAFETY: Test for the unsafe constructor. + ityp::span DAWN_UNSAFE_BUFFERS(sp{data.begin(), data.end()}); + EXPECT_EQ(sp.size(), Index{3u}); + EXPECT_EQ(sp.data(), data.data()); + } + // 2 x const_iterator for ityp::span + { + // SAFETY: Test for the unsafe constructor. + ityp::span DAWN_UNSAFE_BUFFERS(sp{constData.begin(), constData.end()}); + EXPECT_EQ(sp.size(), Index{3u}); + EXPECT_EQ(sp.data(), constData.data()); + } + // 2 x iterator for ityp::span + { + // SAFETY: Test for the unsafe constructor. + ityp::span DAWN_UNSAFE_BUFFERS(sp{data.begin(), data.end()}); + EXPECT_EQ(sp.size(), Index{3u}); + EXPECT_EQ(sp.data(), data.data()); + } +} + +TEST(SpanDeathTest, Constructor_TwoIteratorsInverted) { + std::array data = {1, 2, 3}; + // SAFETY: Test for the unsafe constructor. + DAWN_UNSAFE_BUFFERS(EXPECT_DEATH_IF_SUPPORTED((Span{data.end(), data.begin()}), "")); +} + +TEST(SpanDeathTest, Constructor_TwoIteratorsLargerThanIndexType) { + std::vector data; + data.resize(256); // Larger than indices that can be store in a uint8_t. + + // SAFETY: Test for the unsafe constructor. + DAWN_UNSAFE_BUFFERS( + EXPECT_DEATH_IF_SUPPORTED((ityp::span(data.begin(), data.end())), "")); + + // Fits exactly in uint8_t for indexing. + data.resize(255); + + // SAFETY: Test for the unsafe constructor. + DAWN_UNSAFE_BUFFERS((ityp::span(data.begin(), data.end()))); +} + +std::span GetByteSpan() { + return {}; +} + +TEST(SpanTest, ConstructorFromCompatibleRange) { + { + std::array data = {1, 2, 3}; + Span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } + { + const std::array data = {1, 2, 3}; + Span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } + { + std::vector data{{1, 2, 3}}; + Span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } + { + std::string data = "foo"; + Span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } + { + std::string_view data = "foo"; + Span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } + { + FakeRange data; + Span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } + { + // Fails to compile if the constructor from range take a reference and not an rvalue + // reference. + Span sp; + sp = GetByteSpan(); + } + + { + FakeTypedRange data; + ityp::span sp{data}; + EXPECT_EQ(sp.size(), data.size()); + EXPECT_EQ(sp.data(), data.data()); + } +} + +TEST(SpanTest, CopyConstructor) { + std::array data = {1, 2, 3}; + Span sp{data}; + + Span sp2{sp}; + ASSERT_EQ(sp.data(), sp2.data()); + ASSERT_EQ(sp.size(), sp2.size()); + + // Actually calls the constructor from a range. + Span sp3{sp}; + ASSERT_EQ(sp.data(), sp3.data()); + ASSERT_EQ(sp.size(), sp3.size()); +} + +TEST(SpanTest, CopyAssignment) { + std::array data = {1, 2, 3}; + Span sp{data}; + + Span sp2; + sp2 = sp; + ASSERT_EQ(sp.data(), sp2.data()); + ASSERT_EQ(sp.size(), sp2.size()); + + // Actually calls the constructor from a range and then assigns. + Span sp3; + sp3 = sp; + ASSERT_EQ(sp.data(), sp3.data()); + ASSERT_EQ(sp.size(), sp3.size()); +} + +TEST(SpanTest, MoveConstructor) { + std::array data = {1, 2, 3}; + Span sp{data}; + + Span sp2{std::move(sp)}; + ASSERT_EQ(data.data(), sp2.data()); + ASSERT_EQ(data.size(), sp2.size()); + + // Move actually does a copy so sp stays the same. + ASSERT_EQ(data.data(), sp.data()); + ASSERT_EQ(data.size(), sp.size()); +} + +TEST(SpanTest, MoveAssignment) { + std::array data = {1, 2, 3}; + Span sp{data}; + + Span sp2; + sp2 = std::move(sp); + ASSERT_EQ(data.data(), sp2.data()); + ASSERT_EQ(data.size(), sp2.size()); + + // Move actually does a copy so sp stays the same. + ASSERT_EQ(data.data(), sp.data()); + ASSERT_EQ(data.size(), sp.size()); +} + +TEST(SpanTest, BeginEnd) { + { + Span sp(FakeRange{}); + ASSERT_EQ(&*sp.begin(), &*kSpanData.begin()); + ASSERT_EQ(&*sp.end(), &*kSpanData.end()); + } + { + ityp::span sp(FakeTypedRange{}); + ASSERT_EQ(&*sp.begin(), &*kSpanData.begin()); + ASSERT_EQ(&*sp.end(), &*kSpanData.end()); + } +} + +TEST(SpanTest, BeginEndForIteration) { + // Uses begin/end + { + Span sp(FakeRange{}); + + int expected = 1; + for (const int& i : sp) { + EXPECT_EQ(i, expected); + expected++; + } + } + + // Uses cbegin/cend + { + const Span sp(FakeRange{}); + + int expected = 1; + for (const int& i : sp) { + EXPECT_EQ(i, expected); + expected++; + } + } + + // ityp, uses begin/end + { + ityp::span sp(FakeTypedRange{}); + + int expected = 1; + for (const int& i : sp) { + EXPECT_EQ(i, expected); + expected++; + } + } + + // ityp, uses cbegin/cend + { + const ityp::span sp(FakeTypedRange{}); + + int expected = 1; + for (const int& i : sp) { + EXPECT_EQ(i, expected); + expected++; + } + } +} + +TEST(SpanTest, FrontBack) { + { + Span sp(FakeRange{}); + EXPECT_EQ(&sp.front(), &kSpanData.front()); + EXPECT_EQ(&sp.back(), &kSpanData.back()); + } + { + ityp::span sp(FakeTypedRange{}); + EXPECT_EQ(&sp.front(), &kSpanData.front()); + EXPECT_EQ(&sp.back(), &kSpanData.back()); + } +} + +TEST(SpanDeathTest, FrontBackOfEmpty) { + Span sp; + EXPECT_DEATH_IF_SUPPORTED(sp.front(), ""); + EXPECT_DEATH_IF_SUPPORTED(sp.back(), ""); +} + +TEST(SpanTest, Indexing) { + { + Span sp(FakeRange{}); + for (size_t i = 0; i < kSpanData.size(); i++) { + EXPECT_EQ(&sp.at(i), &kSpanData[i]); + EXPECT_EQ(&sp[i], &kSpanData[i]); + } + } + { + ityp::span sp(FakeTypedRange{}); + for (size_t i = 0; i < kSpanData.size(); i++) { + Index id{static_cast(i)}; + EXPECT_EQ(&sp.at(id), &kSpanData[i]); + EXPECT_EQ(&sp[id], &kSpanData[i]); + } + } +} + +TEST(SpanDeathTest, IndexingOOB) { + Span sp(FakeRange{}); + EXPECT_DEATH_IF_SUPPORTED(sp.at(sp.size()), ""); + EXPECT_DEATH_IF_SUPPORTED(sp[sp.size()], ""); + + Span spEmpty; + EXPECT_DEATH_IF_SUPPORTED(spEmpty.at(0u), ""); + EXPECT_DEATH_IF_SUPPORTED(spEmpty[0u], ""); +} + +TEST(SpanDeathTest, IndexingOversizedIndex) { + // These tests are only relevant on 32-bit builds. + if constexpr (sizeof(size_t) > sizeof(uint32_t)) { + GTEST_SKIP(); + } + + auto sp = ityp::span(FakeTyped64Range()); + + // The narrowing to size_t would give 0 which is in bounds, so this checks that the cast to + // size_t itself causes a crash. + constexpr Index64 kHugeIndex{0x1'0000'0000LLU}; + EXPECT_DEATH_IF_SUPPORTED(sp[kHugeIndex], ""); +} + +// .data() and .size() are tested in every test essentially. + +TEST(SpanTest, Empty) { + ASSERT_FALSE(Span{FakeRange{}}.empty()); + // SAFETY: Test for the unsafe constructor. + ASSERT_FALSE(DAWN_UNSAFE_BUFFERS((Span{static_cast(nullptr), 1u})).empty()); + ASSERT_TRUE(Span{}.empty()); + // SAFETY: Test for the unsafe constructor. + ASSERT_TRUE(DAWN_UNSAFE_BUFFERS((Span{kSpanData.data(), 0u})).empty()); + + ASSERT_FALSE((ityp::span{FakeTypedRange{}}.empty())); + ASSERT_FALSE( + // SAFETY: Test for the unsafe constructor. + DAWN_UNSAFE_BUFFERS((ityp::span{static_cast(nullptr), Index{1u}})) + .empty()); + ASSERT_TRUE((ityp::span{}.empty())); + ASSERT_TRUE( + // SAFETY: Test for the unsafe constructor. + DAWN_UNSAFE_BUFFERS((ityp::span{kSpanData.data(), Index{0u}})).empty()); +} + +TEST(SpanTest, SizeBytes) { + ASSERT_EQ(Span{}.size_bytes(), 0u); + ASSERT_EQ((ityp::span{}.size_bytes()), 0u); + + std::array ints{}; + ASSERT_EQ(Span{ints}.size_bytes(), 3 * sizeof(int)); + + std::array doubles{}; + ASSERT_EQ(Span{doubles}.size_bytes(), 10 * sizeof(double)); +} + +TEST(SpanTest, FirstLast) { + { + Span sp{FakeRange()}; + Span first0 = sp.first(0); + Span first2 = sp.first(2); + Span last0 = sp.last(0); + Span last2 = sp.last(2); + + EXPECT_EQ(first0.data(), sp.data()); + EXPECT_EQ(first0.size(), 0u); + EXPECT_EQ(first2.data(), sp.data()); + EXPECT_EQ(first2.size(), 2u); + + EXPECT_EQ(last0.data(), &*sp.end()); + EXPECT_EQ(last0.size(), 0u); + EXPECT_EQ(last2.data(), &sp.at(sp.size() - 2)); + EXPECT_EQ(last2.size(), 2u); + } + + { + ityp::span sp{FakeTypedRange()}; + ityp::span first0 = sp.first(Index{0u}); + ityp::span first2 = sp.first(Index{2u}); + ityp::span last0 = sp.last(Index{0u}); + ityp::span last2 = sp.last(Index{2u}); + + EXPECT_EQ(first0.data(), sp.data()); + EXPECT_EQ(first0.size(), Index{0u}); + EXPECT_EQ(first2.data(), sp.data()); + EXPECT_EQ(first2.size(), Index{2u}); + + EXPECT_EQ(last0.data(), &*sp.end()); + EXPECT_EQ(last0.size(), Index{0u}); + EXPECT_EQ(last2.data(), &sp.at(sp.size() - Index{2u})); + EXPECT_EQ(last2.size(), Index{2u}); + } +} + +TEST(SpanDeathTest, FirstLastOOB) { + Span sp{FakeRange()}; + + sp.first(sp.size()); + EXPECT_DEATH_IF_SUPPORTED(sp.first(sp.size() + 1), ""); + + sp.last(sp.size()); + EXPECT_DEATH_IF_SUPPORTED(sp.last(sp.size() + 1), ""); +} + +TEST(SpanTest, Subspan1Arg) { + { + Span sp{FakeRange()}; + Span subspan0 = sp.subspan(0); + Span subspan2 = sp.subspan(2); + + EXPECT_EQ(subspan0.data(), sp.data()); + EXPECT_EQ(subspan0.size(), sp.size()); + EXPECT_EQ(subspan2.data(), &sp.at(2)); + EXPECT_EQ(subspan2.size(), sp.size() - 2); + } + { + ityp::span sp{FakeTypedRange()}; + ityp::span subspan0 = sp.subspan(Index{0u}); + ityp::span subspan2 = sp.subspan(Index{2u}); + + EXPECT_EQ(subspan0.data(), sp.data()); + EXPECT_EQ(subspan0.size(), sp.size()); + EXPECT_EQ(subspan2.data(), &sp.at(Index{2u})); + EXPECT_EQ(subspan2.size(), sp.size() - Index{2u}); + } +} + +TEST(SpanDeathTest, Subspan1ArgOOB) { + Span sp{FakeRange()}; + + sp.subspan(sp.size()); + EXPECT_DEATH_IF_SUPPORTED(sp.subspan(sp.size() + 1), ""); +} + +TEST(SpanTest, Subspan2Args) { + { + Span sp{FakeRange()}; + Span subspan0_2 = sp.subspan(0, 2); + Span subspan3_2 = sp.subspan(3, 2); + + EXPECT_EQ(subspan0_2.data(), sp.data()); + EXPECT_EQ(subspan0_2.size(), 2u); + EXPECT_EQ(subspan3_2.data(), &sp.at(3)); + EXPECT_EQ(subspan3_2.size(), 2u); + } + { + ityp::span sp{FakeTypedRange()}; + ityp::span subspan0_2 = sp.subspan(Index{0u}, Index{2u}); + ityp::span subspan3_2 = sp.subspan(Index{3u}, Index{2u}); + + EXPECT_EQ(subspan0_2.data(), sp.data()); + EXPECT_EQ(subspan0_2.size(), Index{2u}); + EXPECT_EQ(subspan3_2.data(), &sp.at(Index{3u})); + EXPECT_EQ(subspan3_2.size(), Index{2u}); + } +} + +TEST(SpanDeathTest, Subspan2ArgOOB) { + Span sp{FakeRange()}; + + sp.subspan(2, sp.size() - 2); + EXPECT_DEATH_IF_SUPPORTED(sp.subspan(2, sp.size() - 1), ""); + + // Check that overflows of offset + count is handled. + EXPECT_DEATH_IF_SUPPORTED(sp.subspan(std::numeric_limits::max(), 1), ""); + EXPECT_DEATH_IF_SUPPORTED(sp.subspan(1, std::numeric_limits::max()), ""); + + // SAFETY: This is the same range as kSpanData, just viewed with a uint8_t index (which fits the + // size of kSpanData since it is 5). + auto sp8 = DAWN_UNSAFE_BUFFERS( + ityp::span(kSpanData.data(), Index8{uint8_t{kSpanData.size()}})); + + Index8 kOne = Index8{uint8_t{1}}; + Index8 kTwo = Index8{uint8_t{2}}; + sp8.subspan(kTwo, sp8.size() - kTwo); + EXPECT_DEATH_IF_SUPPORTED(sp8.subspan(kTwo, sp8.size() - kOne), ""); + + // Check that overflows of offset + count is handled. + EXPECT_DEATH_IF_SUPPORTED(sp8.subspan(std::numeric_limits::max(), kOne), ""); + EXPECT_DEATH_IF_SUPPORTED(sp8.subspan(kOne, std::numeric_limits::max()), ""); +} + +} // anonymous namespace +} // namespace dawn diff --git a/3rdparty/dawn/src/utils/typed_integer.h b/3rdparty/dawn/src/utils/typed_integer.h new file mode 100644 index 000000000..e79bf63e1 --- /dev/null +++ b/3rdparty/dawn/src/utils/typed_integer.h @@ -0,0 +1,321 @@ +// Copyright 2020 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_UTILS_TYPEDINTEGER_H_ +#define SRC_UTILS_TYPEDINTEGER_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "src/utils/assert.h" +#include "src/utils/compiler.h" +#include "src/utils/numeric.h" +#include "src/utils/underlying_type.h" + +namespace dawn { + +// TypedInteger is helper class that provides additional type safety in Debug. +// - Integers of different (Tag, BaseIntegerType) may not be used interoperably +// - Allows casts only to the underlying type. +// - Integers of the same (Tag, BaseIntegerType) may be compared or assigned. +// This class helps ensure that the many types of indices in Dawn aren't mixed up and used +// interchangably. +// +// Example: +// using UintA = dawn::TypedInteger; +// using UintB = dawn::TypedInteger; +// +// in Release: +// using UintA = uint32_t; +// using UintB = uint32_t; +// +// in Debug: +// using UintA = detail::TypedIntegerImpl; +// using UintB = detail::TypedIntegerImpl; +// +// Assignment, construction, comparison, and arithmetic with TypedIntegerImpl are allowed +// only for typed integers of exactly the same type. Further, they must be +// created / cast explicitly; there is no implicit conversion. +// +// UintA a(2); +// uint32_t aValue = static_cast(a); +// +namespace detail { +template +class TypedIntegerImpl; +} // namespace detail + +template +using TypedInteger = detail::TypedIntegerImpl; + +namespace detail { +template +class DAWN_TRIVIAL_ABI alignas(T) TypedIntegerImpl { + static_assert(std::is_integral_v, "TypedInteger must be integral"); + T mValue; + + public: + constexpr TypedIntegerImpl() : mValue(0) { + static_assert(alignof(TypedIntegerImpl) == alignof(T)); + static_assert(sizeof(TypedIntegerImpl) == sizeof(T)); + } + + // Lossless conversion: primitive -> TypedInteger (constructor). + // If you need a lossy (narrowing) conversion, use (d)checked_cast. + template + requires kIsCastAlwaysInRange + explicit constexpr TypedIntegerImpl(Src src) : mValue(static_cast(src)) {} + + // Lossless conversion: TypedInteger -> primitive (cast) + // If you need a lossy (narrowing) conversion, use (d)checked_cast. + template + requires kIsCastAlwaysInRange + explicit constexpr operator Dst() const { + return static_cast(this->mValue); + } + + // Same-tag TypedInteger comparison operators + constexpr auto operator<=>(const TypedIntegerImpl& rhs) const = default; + + // Increment / decrement operators for for-loop iteration + constexpr TypedIntegerImpl& operator++() { + DAWN_ASSERT(this->mValue < std::numeric_limits::max()); + ++this->mValue; + return *this; + } + + constexpr TypedIntegerImpl operator++(int) { + TypedIntegerImpl ret = *this; + + DAWN_ASSERT(this->mValue < std::numeric_limits::max()); + ++this->mValue; + return ret; + } + + constexpr TypedIntegerImpl& operator--() { + DAWN_ASSERT(this->mValue > std::numeric_limits::min()); + --this->mValue; + return *this; + } + + constexpr TypedIntegerImpl operator--(int) { + TypedIntegerImpl ret = *this; + + DAWN_ASSERT(this->mValue > std::numeric_limits::min()); + --this->mValue; + return ret; + } + + constexpr TypedIntegerImpl operator-() const + requires(std::signed_integral) + { + // The negation of the most negative value cannot be represented. + DAWN_ASSERT(this->mValue != std::numeric_limits::min()); + return TypedIntegerImpl(-this->mValue); + } + + constexpr TypedIntegerImpl operator+(TypedIntegerImpl rhs) const + requires(std::unsigned_integral) + { + // Overflow would wrap around + DAWN_ASSERT(mValue + rhs.mValue >= mValue); + T result = mValue + rhs.mValue; + return TypedIntegerImpl{result}; + } + constexpr TypedIntegerImpl operator+(TypedIntegerImpl rhs) const + requires(std::signed_integral) + { + if (mValue > 0) { + // rhs is positive: |rhs| is at most the distance between max and |lhs|. + // rhs is negative: (positive + negative) won't overflow + DAWN_ASSERT(rhs.mValue <= std::numeric_limits::max() - mValue); + } else { + // rhs is positive: (negative + positive) won't underflow + // rhs is negative: |rhs| isn't less than the (negative) distance between min + // and |lhs| + DAWN_ASSERT(rhs.mValue >= std::numeric_limits::min() - mValue); + } + T result = mValue + rhs.mValue; + return TypedIntegerImpl{result}; + } + + constexpr TypedIntegerImpl operator-(TypedIntegerImpl rhs) const + requires(std::unsigned_integral) + { + // Overflow would wrap around + DAWN_ASSERT(mValue - rhs.mValue <= mValue); + T result = mValue - rhs.mValue; + return TypedIntegerImpl{result}; + } + constexpr TypedIntegerImpl operator-(TypedIntegerImpl rhs) const + requires(std::signed_integral) + { + if (mValue > 0) { + // rhs is positive: positive minus positive won't overflow + // rhs is negative: |rhs| isn't less than the (negative) distance between |lhs| + // and max. + DAWN_ASSERT(rhs.mValue >= mValue - std::numeric_limits::max()); + } else { + // rhs is positive: |rhs| is at most the distance between min and |lhs| + // rhs is negative: negative minus negative won't overflow + DAWN_ASSERT(rhs.mValue <= mValue - std::numeric_limits::min()); + } + T result = mValue - rhs.mValue; + return TypedIntegerImpl{result}; + } + + constexpr TypedIntegerImpl operator*(TypedIntegerImpl rhs) const + requires(std::unsigned_integral) + { + DAWN_ASSERT(mValue == 0 || rhs.mValue == 0 || + mValue <= (std::numeric_limits::max() / rhs.mValue)); + T result = mValue * rhs.mValue; + return TypedIntegerImpl{result}; + } + constexpr TypedIntegerImpl operator*(TypedIntegerImpl rhs) const + requires(std::signed_integral) + { + // https://wiki.sei.cmu.edu/confluence/display/c/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow + if (mValue > 0) { + if (rhs.mValue > 0) { + DAWN_ASSERT(mValue <= (std::numeric_limits::max() / rhs.mValue)); + } else { + DAWN_ASSERT(rhs.mValue >= (std::numeric_limits::min() / mValue)); + } + } else { + if (rhs.mValue > 0) { + DAWN_ASSERT(mValue >= (std::numeric_limits::min() / rhs.mValue)); + } else { + DAWN_ASSERT((mValue == 0) || + (rhs.mValue >= (std::numeric_limits::max() / mValue))); + } + } + T result = mValue * rhs.mValue; + return TypedIntegerImpl{result}; + } + + constexpr TypedIntegerImpl operator/(TypedIntegerImpl rhs) const + requires(std::unsigned_integral) + { + DAWN_ASSERT(rhs.mValue != 0); + T result = mValue / rhs.mValue; + return TypedIntegerImpl{result}; + } + constexpr TypedIntegerImpl operator/(TypedIntegerImpl rhs) const + requires(std::signed_integral) + { + // https://wiki.sei.cmu.edu/confluence/display/c/INT33-C.+Ensure+that+division+and+remainder+operations+do+not+result+in+divide-by-zero+errors + DAWN_ASSERT( + !(rhs.mValue == 0 || (rhs.mValue == -1 && mValue == std::numeric_limits::min()))); + T result = mValue / rhs.mValue; + return TypedIntegerImpl{result}; + } + + constexpr TypedIntegerImpl operator%(TypedIntegerImpl rhs) const + requires(std::unsigned_integral) + { + DAWN_ASSERT(rhs.mValue != 0); + T result = mValue % rhs.mValue; + return TypedIntegerImpl{result}; + } + constexpr TypedIntegerImpl operator%(TypedIntegerImpl rhs) const + requires(std::signed_integral) + { + // https://wiki.sei.cmu.edu/confluence/display/c/INT33-C.+Ensure+that+division+and+remainder+operations+do+not+result+in+divide-by-zero+errors + DAWN_ASSERT( + !(rhs.mValue == 0 || (rhs.mValue == -1 && mValue == std::numeric_limits::min()))); + T result = mValue % rhs.mValue; + return TypedIntegerImpl{result}; + } + + constexpr TypedIntegerImpl& operator+=(const TypedIntegerImpl& rhs) { + *this = *this + rhs; + return *this; + } + + constexpr TypedIntegerImpl& operator-=(const TypedIntegerImpl& rhs) { + *this = *this - rhs; + return *this; + } + + constexpr TypedIntegerImpl& operator*=(const TypedIntegerImpl& rhs) { + *this = *this * rhs; + return *this; + } + + constexpr TypedIntegerImpl& operator/=(const TypedIntegerImpl& rhs) { + *this = *this / rhs; + return *this; + } + + constexpr TypedIntegerImpl& operator%=(const TypedIntegerImpl& rhs) { + *this = *this % rhs; + return *this; + } + + // Helper functions to avoid the need to do a double cast when we just want to add 1 to a typed + // integer (when ++ or -- are not options). + TypedIntegerImpl PlusOne() const { return *this + TypedIntegerImpl{T{1}}; } + TypedIntegerImpl MinusOne() const { return *this - TypedIntegerImpl{T{1}}; } + + template + friend H AbslHashValue(H state, const TypedIntegerImpl& value) { + H::combine(std::move(state), value.mValue); + return std::move(state); + } +}; + +template +std::ostream& operator<<(std::ostream& os, TypedIntegerImpl value) { + os << static_cast(value); + return os; +} + +} // namespace detail +} // namespace dawn + +namespace std { + +template +class numeric_limits> : public numeric_limits { + public: + static constexpr dawn::detail::TypedIntegerImpl max() noexcept { + return dawn::detail::TypedIntegerImpl(std::numeric_limits::max()); + } + static constexpr dawn::detail::TypedIntegerImpl min() noexcept { + return dawn::detail::TypedIntegerImpl(std::numeric_limits::min()); + } +}; + +} // namespace std + +#endif // SRC_UTILS_TYPEDINTEGER_H_ diff --git a/3rdparty/dawn/src/utils/typed_integer_nocompile.nc b/3rdparty/dawn/src/utils/typed_integer_nocompile.nc new file mode 100644 index 000000000..6f50c5b9f --- /dev/null +++ b/3rdparty/dawn/src/utils/typed_integer_nocompile.nc @@ -0,0 +1,81 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Test the type checks of TypedInteger in debug and release. +// Strong checks are enabled only in debug. + +#include "src/utils/typed_integer.h" + +namespace dawn { + +using MyI32 = TypedInteger; +using MyU32 = TypedInteger; + +using MyOtherI32 = TypedInteger; + +static uint8_t v = 3; +static MyI32 i{3}; +static MyU32 u{3u}; + +// Construction of TypedInteger from other things. +void TestConstruction() { + // Cannot construct from a distinct but otherwise identical type. + (void) MyI32{MyI32{v}}; // (control case) + (void) MyI32{MyOtherI32{v}}; // expected-error {{no matching constructor for initialization of}} + + // Cannot convert to narrower types. + (void) MyI32{int32_t{v}}; // (control case) + (void) MyI32{int64_t{v}}; // expected-error {{no matching constructor for initialization of}} + (void) MyI32{uint32_t{v}}; // expected-error {{no matching constructor for initialization of}} + (void) MyU32{uint64_t{v}}; // expected-error {{no matching constructor for initialization of}} + (void) MyU32{int16_t{v}}; // expected-error {{no matching constructor for initialization of}} + (void) MyU32{int32_t{v}}; // expected-error {{no matching constructor for initialization of}} +} + +// Assignment to TypedInteger from other things. +void TestAssignmentToTyped() { + { [[maybe_unused]] MyI32 x = MyI32{v}; } // (control case.) + { [[maybe_unused]] MyI32 x = int32_t{v}; } // expected-error {{no viable conversion from}} + { [[maybe_unused]] MyI32 x = MyOtherI32{v}; } // expected-error {{no viable conversion from}} +} + +// Casts from TypedInteger to primitive. +void TestCastToPrimitive() { + // Cannot convert to narrower types. + (void) int32_t{i}; // (control case.) + (void) int16_t{i}; // expected-error {{no viable conversion from}} + (void) uint32_t{i}; // expected-error {{no viable conversion from}} + (void) int32_t{u}; // expected-error {{no viable conversion from}} +} + +// Assignment to primitive from TypedInteger. +void TestAssignmentToPrimitive() { + { [[maybe_unused]] int32_t x = int32_t{v}; } // (control case.) + { [[maybe_unused]] int32_t x = MyI32{v}; } // expected-error {{no viable conversion from}} +} + +} diff --git a/3rdparty/dawn/src/utils/typed_integer_tests.cc b/3rdparty/dawn/src/utils/typed_integer_tests.cc new file mode 100644 index 000000000..94a53de22 --- /dev/null +++ b/3rdparty/dawn/src/utils/typed_integer_tests.cc @@ -0,0 +1,594 @@ +// Copyright 2020 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include + +#include "gtest/gtest.h" +#include "src/utils/typed_integer.h" +#include "src/utils/underlying_type.h" + +namespace dawn { +namespace { + +class TypedIntegerTest : public testing::Test { + protected: + using Unsigned = TypedInteger; + using Signed = TypedInteger; +}; + +// Test that typed integers can be created and cast and the internal values are identical +TEST_F(TypedIntegerTest, ConstructionAndCast) { + Signed svalue(2); + EXPECT_EQ(static_cast(svalue), 2); + + Unsigned uvalue(7u); + EXPECT_EQ(static_cast(uvalue), 7u); + + static_assert(static_cast(Signed(3)) == 3); + static_assert(static_cast(Unsigned(28u)) == 28); +} + +// Test that typed integers can be explicitly cast to other integral types +// (either using a static_cast or a checked_cast depending on the type pair). +TEST_F(TypedIntegerTest, CastToOther) { + using Unsigned64 = TypedInteger; + using Signed64 = TypedInteger; + using Unsigned32 = TypedInteger; + using Signed32 = TypedInteger; + using Unsigned16 = TypedInteger; + using Signed16 = TypedInteger; + + constexpr int32_t maxI32 = std::numeric_limits::max(); + constexpr int16_t maxI16 = std::numeric_limits::max(); + constexpr int8_t maxI8 = std::numeric_limits::max(); + constexpr uint32_t maxU32 = std::numeric_limits::max(); + constexpr uint16_t maxU16 = std::numeric_limits::max(); + constexpr uint8_t maxU8 = std::numeric_limits::max(); + + { + Signed64 svalue64(maxI32); + EXPECT_EQ(checked_cast(svalue64), maxI32); + + Signed32 svalue32(maxI16); + EXPECT_EQ(static_cast(svalue32), maxI16); + + Signed16 svalue16(maxI8); + EXPECT_EQ(checked_cast(svalue16), maxI8); + } + { + Unsigned64 uvalue64(maxU32); + EXPECT_EQ(checked_cast(uvalue64), maxU32); + + Unsigned32 uvalue32(maxU16); + EXPECT_EQ(static_cast(uvalue32), maxU16); + + Unsigned16 uvalue16(maxU8); + EXPECT_EQ(checked_cast(uvalue16), maxU8); + } + { + Signed64 svalue64(maxI8); + EXPECT_EQ(checked_cast(svalue64), maxI8); + EXPECT_EQ(checked_cast(svalue64), maxI8); + EXPECT_EQ(checked_cast(svalue64), maxI8); + } + { + Unsigned64 uvalue64(maxU8); + EXPECT_EQ(checked_cast(uvalue64), maxU8); + EXPECT_EQ(checked_cast(uvalue64), maxU8); + EXPECT_EQ(checked_cast(uvalue64), maxU8); + } +} + +// Test typed integer comparison operators +TEST_F(TypedIntegerTest, Comparison) { + Unsigned value(8u); + + // Truthy usages of comparison operators + EXPECT_TRUE(value < Unsigned(9u)); + EXPECT_TRUE(value <= Unsigned(9u)); + EXPECT_TRUE(value <= Unsigned(8u)); + EXPECT_TRUE(value == Unsigned(8u)); + EXPECT_TRUE(value >= Unsigned(8u)); + EXPECT_TRUE(value >= Unsigned(7u)); + EXPECT_TRUE(value > Unsigned(7u)); + EXPECT_TRUE(value != Unsigned(7u)); + + // Falsy usages of comparison operators + EXPECT_FALSE(value >= Unsigned(9u)); + EXPECT_FALSE(value > Unsigned(9u)); + EXPECT_FALSE(value > Unsigned(8u)); + EXPECT_FALSE(value != Unsigned(8u)); + EXPECT_FALSE(value < Unsigned(8u)); + EXPECT_FALSE(value < Unsigned(7u)); + EXPECT_FALSE(value <= Unsigned(7u)); + EXPECT_FALSE(value == Unsigned(7u)); +} + +TEST_F(TypedIntegerTest, Arithmetic) { + // Postfix Increment + { + Signed value(0); + EXPECT_EQ(value++, Signed(0)); + EXPECT_EQ(value, Signed(1)); + } + + // Prefix Increment + { + Signed value(0); + EXPECT_EQ(++value, Signed(1)); + EXPECT_EQ(value, Signed(1)); + } + + // Postfix Decrement + { + Signed value(0); + EXPECT_EQ(value--, Signed(0)); + EXPECT_EQ(value, Signed(-1)); + } + + // Prefix Decrement + { + Signed value(0); + EXPECT_EQ(--value, Signed(-1)); + EXPECT_EQ(value, Signed(-1)); + } + + // Signed addition + { + Signed a(3); + Signed b(-4); + Signed c = a + b; + EXPECT_EQ(a, Signed(3)); + EXPECT_EQ(b, Signed(-4)); + EXPECT_EQ(c, Signed(-1)); + } + + // Signed subtraction + { + Signed a(3); + Signed b(-4); + Signed c = a - b; + EXPECT_EQ(a, Signed(3)); + EXPECT_EQ(b, Signed(-4)); + EXPECT_EQ(c, Signed(7)); + } + + // Unsigned addition + { + Unsigned a(9u); + Unsigned b(3u); + Unsigned c = a + b; + EXPECT_EQ(a, Unsigned(9u)); + EXPECT_EQ(b, Unsigned(3u)); + EXPECT_EQ(c, Unsigned(12u)); + } + + // Unsigned subtraction + { + Unsigned a(9u); + Unsigned b(2u); + Unsigned c = a - b; + EXPECT_EQ(a, Unsigned(9u)); + EXPECT_EQ(b, Unsigned(2u)); + EXPECT_EQ(c, Unsigned(7u)); + } + + // Negation + { + Signed a(5); + Signed b = -a; + EXPECT_EQ(a, Signed(5)); + EXPECT_EQ(b, Signed(-5)); + } + + // Signed multiplication + { + Signed a(3); + Signed b(-4); + Signed c = a * b; + EXPECT_EQ(a, Signed(3)); + EXPECT_EQ(b, Signed(-4)); + EXPECT_EQ(c, Signed(-12)); + } + + // Unsigned multiplication + { + Unsigned a(9u); + Unsigned b(3u); + Unsigned c = a * b; + EXPECT_EQ(a, Unsigned(9u)); + EXPECT_EQ(b, Unsigned(3u)); + EXPECT_EQ(c, Unsigned(27u)); + } + + // Signed division + { + Signed a(12); + Signed b(-4); + Signed c = a / b; + EXPECT_EQ(a, Signed(12)); + EXPECT_EQ(b, Signed(-4)); + EXPECT_EQ(c, Signed(-3)); + } + + // Unsigned division + { + Unsigned a(12u); + Unsigned b(3u); + Unsigned c = a / b; + EXPECT_EQ(a, Unsigned(12u)); + EXPECT_EQ(b, Unsigned(3u)); + EXPECT_EQ(c, Unsigned(4u)); + } + + // Signed modulo + { + Signed a(12); + Signed b(-5); + Signed c = a % b; + EXPECT_EQ(a, Signed(12)); + EXPECT_EQ(b, Signed(-5)); + EXPECT_EQ(c, Signed(2)); + } + + // Unsigned modulo + { + Unsigned a(12u); + Unsigned b(5u); + Unsigned c = a % b; + EXPECT_EQ(a, Unsigned(12u)); + EXPECT_EQ(b, Unsigned(5u)); + EXPECT_EQ(c, Unsigned(2u)); + } +} + +TEST_F(TypedIntegerTest, ArithmeticAssignment) { + // Signed addition assignment + { + Signed a(3); + Signed b(-4); + a += b; + EXPECT_EQ(a, Signed(-1)); + EXPECT_EQ(b, Signed(-4)); + } + + // Signed subtraction assignment + { + Signed a(3); + Signed b(-4); + a -= b; + EXPECT_EQ(a, Signed(7)); + EXPECT_EQ(b, Signed(-4)); + } + + // Unsigned addition assignment + { + Unsigned a(9u); + Unsigned b(3u); + a += b; + EXPECT_EQ(a, Unsigned(12u)); + EXPECT_EQ(b, Unsigned(3u)); + } + + // Unsigned subtraction assignment + { + Unsigned a(9u); + Unsigned b(2u); + a -= b; + EXPECT_EQ(a, Unsigned(7u)); + EXPECT_EQ(b, Unsigned(2u)); + } + + // Signed multiplication assignment + { + Signed a(3); + Signed b(-4); + a *= b; + EXPECT_EQ(a, Signed(-12)); + EXPECT_EQ(b, Signed(-4)); + } + + // Unsigned multiplication assignment + { + Unsigned a(9u); + Unsigned b(3u); + a *= b; + EXPECT_EQ(a, Unsigned(27u)); + EXPECT_EQ(b, Unsigned(3u)); + } + + // Signed division assignment + { + Signed a(12); + Signed b(-4); + a /= b; + EXPECT_EQ(a, Signed(-3)); + EXPECT_EQ(b, Signed(-4)); + } + + // Unsigned division assignment + { + Unsigned a(12u); + Unsigned b(3u); + a /= b; + EXPECT_EQ(a, Unsigned(4u)); + EXPECT_EQ(b, Unsigned(3u)); + } + + // Signed modulo assignment + { + Signed a(12); + Signed b(-5); + a %= b; + EXPECT_EQ(a, Signed(2)); + EXPECT_EQ(b, Signed(-5)); + } + + // Unsigned modulo assignment + { + Unsigned a(12u); + Unsigned b(5u); + a %= b; + EXPECT_EQ(a, Unsigned(2u)); + EXPECT_EQ(b, Unsigned(5u)); + } +} + +TEST_F(TypedIntegerTest, PlusOne) { + EXPECT_EQ(Unsigned(11u).PlusOne(), Unsigned(12u)); + EXPECT_EQ(Signed(11).PlusOne(), Signed(12)); + EXPECT_EQ(Signed(-1).PlusOne(), Signed(0)); +} + +TEST_F(TypedIntegerTest, MinusOne) { + EXPECT_EQ(Unsigned(11u).MinusOne(), Unsigned(10u)); + EXPECT_EQ(Signed(11).MinusOne(), Signed(10)); + EXPECT_EQ(Signed(1).MinusOne(), Signed(0)); +} + +TEST_F(TypedIntegerTest, NumericLimits) { + EXPECT_EQ(std::numeric_limits::max(), Unsigned(std::numeric_limits::max())); + EXPECT_EQ(std::numeric_limits::min(), Unsigned(std::numeric_limits::min())); + EXPECT_EQ(std::numeric_limits::max(), Signed(std::numeric_limits::max())); + EXPECT_EQ(std::numeric_limits::min(), Signed(std::numeric_limits::min())); +} + +TEST_F(TypedIntegerTest, NotIntegral) { + static_assert(!std::is_integral_v); + static_assert(!std::is_integral_v); +} + +TEST_F(TypedIntegerTest, UnderlyingType) { + static_assert(std::is_same_v, uint32_t>); + static_assert(std::is_same_v, int32_t>); +} + +TEST_F(TypedIntegerTest, HasUnsignedUnderlyingType) { + static_assert(!HasUnsignedUnderlyingType); + static_assert(HasUnsignedUnderlyingType); +} + +// Name "*DeathTest" per https://google.github.io/googletest/advanced.html#death-test-naming +using TypedIntegerDeathTest = TypedIntegerTest; + +// Tests for bounds assertions on arithmetic overflow and underflow. +// Note (d)checked_cast tests are in NumericDeathTest. +#if defined(DAWN_ENABLE_ASSERTS) && GTEST_HAS_DEATH_TEST + +TEST_F(TypedIntegerDeathTest, IncrementUnsignedOverflow) { + Unsigned value(std::numeric_limits::max() - 1); + + value++; // Doesn't overflow. + EXPECT_DEATH(value++, ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, IncrementSignedOverflow) { + Signed value(std::numeric_limits::max() - 1); + + value++; // Doesn't overflow. + EXPECT_DEATH(value++, ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, DecrementUnsignedUnderflow) { + Unsigned value(std::numeric_limits::min() + 1); + + value--; // Doesn't underflow. + EXPECT_DEATH(value--, ""); // Underflows. +} + +TEST_F(TypedIntegerDeathTest, DecrementSignedUnderflow) { + Signed value(std::numeric_limits::min() + 1); + + value--; // Doesn't underflow. + EXPECT_DEATH(value--, ""); // Underflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedAdditionOverflow) { + Unsigned value(std::numeric_limits::max() - 1); + + value + Unsigned(1u); // Doesn't overflow. + EXPECT_DEATH(value + Unsigned(2u), ""); // Overflows. + EXPECT_DEATH(value += Unsigned(2u), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedAdditionOverflow) { + Signed value(std::numeric_limits::max() - 1); + + value + Signed(1); // Doesn't overflow. + EXPECT_DEATH(value + Signed(2), ""); // Overflows. + EXPECT_DEATH(value += Signed(2), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedAdditionUnderflow) { + Signed value(std::numeric_limits::min() + 1); + + value + Signed(-1); // Doesn't underflow. + EXPECT_DEATH(value + Signed(-2), ""); // Underflows. + EXPECT_DEATH(value += Signed(-2), ""); // Underflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedSubtractionUnderflow) { + Unsigned value(1u); + + value - Unsigned(1u); // Doesn't underflow. + EXPECT_DEATH(value - Unsigned(2u), ""); // Underflows. + EXPECT_DEATH(value -= Unsigned(2u), ""); // Underflows. +} + +TEST_F(TypedIntegerDeathTest, SignedSubtractionOverflow) { + Signed value(std::numeric_limits::max() - 1); + + value - Signed(-1); // Doesn't overflow. + EXPECT_DEATH(value - Signed(-2), ""); // Overflows. + EXPECT_DEATH(value -= Signed(-2), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedSubtractionUnderflow) { + Signed value(std::numeric_limits::min() + 1); + + value - Signed(1); // Doesn't underflow. + EXPECT_DEATH(value - Signed(2), ""); // Underflows. + EXPECT_DEATH(value -= Signed(2), ""); // Underflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedMultiplicationOverflow) { + Unsigned value(std::numeric_limits::max() / 2); + + value* Unsigned(2u); // Doesn't overflow. + EXPECT_DEATH(value * Unsigned(3u), ""); // Overflows. + EXPECT_DEATH(value *= Unsigned(3u), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedMultiplicationOverflow) { + Signed value(std::numeric_limits::max() / 2); + + value* Signed(2); // Doesn't overflow. + EXPECT_DEATH(value * Signed(3), ""); // Overflows. + EXPECT_DEATH(value *= Signed(3), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedMultiplicationUnderflow) { + Signed value(std::numeric_limits::min() / 2); + + value* Signed(2); // Doesn't underflow. + EXPECT_DEATH(value * Signed(3), ""); // Underflows. + EXPECT_DEATH(value *= Signed(3), ""); // Underflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedDivisionByZero) { + Unsigned value(1u); + + value / Unsigned(1u); // Doesn't underflow. + EXPECT_DEATH(value / Unsigned(0u), ""); // DBZ. + EXPECT_DEATH(value /= Unsigned(0u), ""); // DBZ. +} + +TEST_F(TypedIntegerDeathTest, SignedDivisionByZero) { + Signed value(1); + + value / Signed(-1); // Doesn't overflow. + EXPECT_DEATH(value / Signed(0), ""); // DBZ. + EXPECT_DEATH(value /= Signed(0), ""); // DBZ. +} + +TEST_F(TypedIntegerDeathTest, SignedDivisionOverflow) { + // Overflow can also occur during two's complement signed integer division when the dividend is + // equal to the minimum (most negative) value for the signed integer type and the divisor is + // equal to −1. + Signed value(std::numeric_limits::min()); + + value / Signed(1); // Doesn't overflow. + EXPECT_DEATH(value / Signed(-1), ""); // Overflows. + EXPECT_DEATH(value /= Signed(-1), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedModuloByZero) { + Unsigned value(1u); + + value % Unsigned(1u); // Doesn't underflow. + EXPECT_DEATH(value % Unsigned(0u), ""); // DBZ. + EXPECT_DEATH(value %= Unsigned(0u), ""); // DBZ. +} + +TEST_F(TypedIntegerDeathTest, SignedModuloByZero) { + Signed value(1); + + value % Signed(-1); // Doesn't overflow. + EXPECT_DEATH(value % Signed(0), ""); // DBZ. + EXPECT_DEATH(value %= Signed(0), ""); // DBZ. +} + +TEST_F(TypedIntegerDeathTest, SignedModuloOverflow) { + // Overflow can also occur during two's complement signed integer modulo when the dividend is + // equal to the minimum (most negative) value for the signed integer type and the divisor is + // equal to −1. + Signed value(std::numeric_limits::min()); + + value % Signed(1); // Doesn't overflow. + EXPECT_DEATH(value % Signed(-1), ""); // Overflows. + EXPECT_DEATH(value %= Signed(-1), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, NegationOverflow) { + Signed maxValue(std::numeric_limits::max()); + -maxValue; // Doesn't underflow. + + Signed minValue(std::numeric_limits::min()); + EXPECT_DEATH(-minValue, ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedPlusOneOverflow) { + Unsigned value(std::numeric_limits::max() - 1); + + value.PlusOne(); // Doesn't overflow. + EXPECT_DEATH(value.PlusOne().PlusOne(), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedPlusOneOverflow) { + Signed value(std::numeric_limits::max() - 1); + + value.PlusOne(); // Doesn't overflow. + EXPECT_DEATH(value.PlusOne().PlusOne(), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, UnsignedMinusOneOverflow) { + Unsigned value(std::numeric_limits::lowest() + 1); + + value.MinusOne(); // Doesn't overflow. + EXPECT_DEATH(value.MinusOne().MinusOne(), ""); // Overflows. +} + +TEST_F(TypedIntegerDeathTest, SignedMinusOneOverflow) { + Signed value(std::numeric_limits::lowest() + 1); + + value.MinusOne(); // Doesn't overflow. + EXPECT_DEATH(value.MinusOne().MinusOne(), ""); // Overflows. +} +#endif // defined(DAWN_ENABLE_ASSERTS) && GTEST_HAS_DEATH_TEST + +} // anonymous namespace +} // namespace dawn diff --git a/3rdparty/dawn/src/utils/underlying_type.h b/3rdparty/dawn/src/utils/underlying_type.h new file mode 100644 index 000000000..0be9c277a --- /dev/null +++ b/3rdparty/dawn/src/utils/underlying_type.h @@ -0,0 +1,77 @@ +// Copyright 2020 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_UTILS_UNDERLYING_TYPE_H_ +#define SRC_UTILS_UNDERLYING_TYPE_H_ + +#include +#include + +namespace dawn { + +// UnderlyingType is similar to std::underlying_type_t. It is a passthrough for already +// integer types which simplifies getting the underlying primitive type for an arbitrary +// template parameter. It includes a specialization for detail::TypedIntegerImpl which yields +// the wrapped integer type. +namespace detail { +template +struct UnderlyingTypeImpl; + +template + requires std::integral +struct UnderlyingTypeImpl { + using type = I; +}; + +template + requires std::is_enum_v +struct UnderlyingTypeImpl { + using type = std::underlying_type_t; +}; + +// Forward declare the TypedInteger impl. +template +class TypedIntegerImpl; + +template +struct UnderlyingTypeImpl> { + using type = typename UnderlyingTypeImpl::type; +}; +} // namespace detail + +template +using UnderlyingType = typename detail::UnderlyingTypeImpl::type; + +template +concept HasUnderlyingType = std::integral>; + +template +concept HasUnsignedUnderlyingType = std::unsigned_integral>; + +} // namespace dawn + +#endif // SRC_UTILS_UNDERLYING_TYPE_H_ diff --git a/3rdparty/dawn/src/utils/underlying_type_tests.cc b/3rdparty/dawn/src/utils/underlying_type_tests.cc new file mode 100644 index 000000000..176fd8f97 --- /dev/null +++ b/3rdparty/dawn/src/utils/underlying_type_tests.cc @@ -0,0 +1,77 @@ +// Copyright 2026 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include + +#include + +#include "src/utils/underlying_type.h" + +namespace dawn { +namespace { + +enum class SignedEnum : int32_t { + A, + B, + C, +}; +enum class UnsignedEnum : uint32_t { + A, + B, + C, +}; + +// Tests for the HasUnsignedUnderlyingType concept. +static_assert(HasUnsignedUnderlyingType); +static_assert(HasUnsignedUnderlyingType); +static_assert(HasUnsignedUnderlyingType); +static_assert(HasUnsignedUnderlyingType); +static_assert(HasUnsignedUnderlyingType); +static_assert(!HasUnsignedUnderlyingType); +static_assert(!HasUnsignedUnderlyingType); +static_assert(!HasUnsignedUnderlyingType); +static_assert(!HasUnsignedUnderlyingType); + +static_assert(!HasUnsignedUnderlyingType); +static_assert(HasUnsignedUnderlyingType); + +// Tests for UnderlyingType +static_assert(std::is_same_v, size_t>); +static_assert(std::is_same_v, uint8_t>); +static_assert(std::is_same_v, uint16_t>); +static_assert(std::is_same_v, uint32_t>); +static_assert(std::is_same_v, uint64_t>); +static_assert(std::is_same_v, int8_t>); +static_assert(std::is_same_v, int16_t>); +static_assert(std::is_same_v, int32_t>); +static_assert(std::is_same_v, int64_t>); + +static_assert(std::is_same_v, int32_t>); +static_assert(std::is_same_v, uint32_t>); + +} // anonymous namespace +} // namespace dawn diff --git a/3rdparty/dawn/src/utils/windows_with_undefs.h b/3rdparty/dawn/src/utils/windows_with_undefs.h new file mode 100644 index 000000000..dd16ac560 --- /dev/null +++ b/3rdparty/dawn/src/utils/windows_with_undefs.h @@ -0,0 +1,51 @@ +// Copyright 2018 The Dawn & Tint Authors +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// 1. Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// 3. Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef SRC_DAWN_COMMON_WINDOWS_WITH_UNDEFS_H_ +#define SRC_DAWN_COMMON_WINDOWS_WITH_UNDEFS_H_ + +#include "src/utils/platform.h" + +#if !DAWN_PLATFORM_IS(WINDOWS) +#error "windows_with_undefs.h included on non-Windows" +#endif + +// This header includes but removes all the extra defines that conflict with identifiers +// in internal code. It should never be included in something that is part of the public interface. +#include + +// Macros defined for ANSI / Unicode support +#undef CreateWindow +#undef GetMessage + +// Macros defined to produce compiler intrinsics +#undef MemoryBarrier + +// Macro defined as an alias of GetTickCount +#undef GetCurrentTime + +#endif // SRC_DAWN_COMMON_WINDOWS_WITH_UNDEFS_H_ diff --git a/examples/runtime/shaders/wgsl/cs_assao_apply.bin b/examples/runtime/shaders/wgsl/cs_assao_apply.bin index fe8f4d318..8cfe36d54 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_apply.bin and b/examples/runtime/shaders/wgsl/cs_assao_apply.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_generate_q0.bin b/examples/runtime/shaders/wgsl/cs_assao_generate_q0.bin index 877ba2248..b7e0186a5 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_generate_q0.bin and b/examples/runtime/shaders/wgsl/cs_assao_generate_q0.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_generate_q1.bin b/examples/runtime/shaders/wgsl/cs_assao_generate_q1.bin index 91c03bd98..cff2e6a7a 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_generate_q1.bin and b/examples/runtime/shaders/wgsl/cs_assao_generate_q1.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_generate_q2.bin b/examples/runtime/shaders/wgsl/cs_assao_generate_q2.bin index 5ee6baa5a..059c3faa9 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_generate_q2.bin and b/examples/runtime/shaders/wgsl/cs_assao_generate_q2.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_generate_q3.bin b/examples/runtime/shaders/wgsl/cs_assao_generate_q3.bin index 243681de6..65e91de8b 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_generate_q3.bin and b/examples/runtime/shaders/wgsl/cs_assao_generate_q3.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_generate_q3base.bin b/examples/runtime/shaders/wgsl/cs_assao_generate_q3base.bin index f35879268..de004bfd1 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_generate_q3base.bin and b/examples/runtime/shaders/wgsl/cs_assao_generate_q3base.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_non_smart_apply.bin b/examples/runtime/shaders/wgsl/cs_assao_non_smart_apply.bin index 771703cb7..1b15f8643 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_non_smart_apply.bin and b/examples/runtime/shaders/wgsl/cs_assao_non_smart_apply.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_non_smart_blur.bin b/examples/runtime/shaders/wgsl/cs_assao_non_smart_blur.bin index 81ee41646..63b512f07 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_non_smart_blur.bin and b/examples/runtime/shaders/wgsl/cs_assao_non_smart_blur.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_non_smart_half_apply.bin b/examples/runtime/shaders/wgsl/cs_assao_non_smart_half_apply.bin index 8dd6d7467..341990e51 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_non_smart_half_apply.bin and b/examples/runtime/shaders/wgsl/cs_assao_non_smart_half_apply.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_postprocess_importance_map_a.bin b/examples/runtime/shaders/wgsl/cs_assao_postprocess_importance_map_a.bin index 9e7c953f0..fe80b2d2f 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_postprocess_importance_map_a.bin and b/examples/runtime/shaders/wgsl/cs_assao_postprocess_importance_map_a.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_prepare_depth_mip.bin b/examples/runtime/shaders/wgsl/cs_assao_prepare_depth_mip.bin index 899735376..d44d8f8ad 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_prepare_depth_mip.bin and b/examples/runtime/shaders/wgsl/cs_assao_prepare_depth_mip.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths.bin b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths.bin index a07a1c6ef..d805b76cf 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths.bin and b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals.bin b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals.bin index cb0d2ac21..48c9f1ec9 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals.bin and b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals_half.bin b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals_half.bin index 4d5d98821..2617586ee 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals_half.bin and b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_and_normals_half.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_half.bin b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_half.bin index 98b12fac0..c86b36e0f 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_half.bin and b/examples/runtime/shaders/wgsl/cs_assao_prepare_depths_half.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_smart_blur.bin b/examples/runtime/shaders/wgsl/cs_assao_smart_blur.bin index 465dddcbe..7658c31c1 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_smart_blur.bin and b/examples/runtime/shaders/wgsl/cs_assao_smart_blur.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_assao_smart_blur_wide.bin b/examples/runtime/shaders/wgsl/cs_assao_smart_blur_wide.bin index 00f780f83..cfec55d75 100644 Binary files a/examples/runtime/shaders/wgsl/cs_assao_smart_blur_wide.bin and b/examples/runtime/shaders/wgsl/cs_assao_smart_blur_wide.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_fsr_bilinear_16.bin b/examples/runtime/shaders/wgsl/cs_fsr_bilinear_16.bin index 0b1d83055..f591ebc29 100644 Binary files a/examples/runtime/shaders/wgsl/cs_fsr_bilinear_16.bin and b/examples/runtime/shaders/wgsl/cs_fsr_bilinear_16.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_fsr_bilinear_32.bin b/examples/runtime/shaders/wgsl/cs_fsr_bilinear_32.bin index 10218b96d..d93a01413 100644 Binary files a/examples/runtime/shaders/wgsl/cs_fsr_bilinear_32.bin and b/examples/runtime/shaders/wgsl/cs_fsr_bilinear_32.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_fsr_easu_16.bin b/examples/runtime/shaders/wgsl/cs_fsr_easu_16.bin index a8293599e..2efa2fcbd 100644 Binary files a/examples/runtime/shaders/wgsl/cs_fsr_easu_16.bin and b/examples/runtime/shaders/wgsl/cs_fsr_easu_16.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_fsr_easu_32.bin b/examples/runtime/shaders/wgsl/cs_fsr_easu_32.bin index b6341faa9..ea4e39e82 100644 Binary files a/examples/runtime/shaders/wgsl/cs_fsr_easu_32.bin and b/examples/runtime/shaders/wgsl/cs_fsr_easu_32.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_fsr_rcas_16.bin b/examples/runtime/shaders/wgsl/cs_fsr_rcas_16.bin index b077a2439..606ef50f9 100644 Binary files a/examples/runtime/shaders/wgsl/cs_fsr_rcas_16.bin and b/examples/runtime/shaders/wgsl/cs_fsr_rcas_16.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_gdr_occlude_props.bin b/examples/runtime/shaders/wgsl/cs_gdr_occlude_props.bin index 9cae4ff8a..0b54031ab 100644 Binary files a/examples/runtime/shaders/wgsl/cs_gdr_occlude_props.bin and b/examples/runtime/shaders/wgsl/cs_gdr_occlude_props.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_gdr_stream_compaction.bin b/examples/runtime/shaders/wgsl/cs_gdr_stream_compaction.bin index 3c63a28b8..32b9e1760 100644 Binary files a/examples/runtime/shaders/wgsl/cs_gdr_stream_compaction.bin and b/examples/runtime/shaders/wgsl/cs_gdr_stream_compaction.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_init_instances.bin b/examples/runtime/shaders/wgsl/cs_init_instances.bin index 9bdc45a32..e7a7856f3 100644 Binary files a/examples/runtime/shaders/wgsl/cs_init_instances.bin and b/examples/runtime/shaders/wgsl/cs_init_instances.bin differ diff --git a/examples/runtime/shaders/wgsl/cs_terrain_lod.bin b/examples/runtime/shaders/wgsl/cs_terrain_lod.bin index 270d073f7..ed0aa4ebf 100644 Binary files a/examples/runtime/shaders/wgsl/cs_terrain_lod.bin and b/examples/runtime/shaders/wgsl/cs_terrain_lod.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_bokeh_forward.bin b/examples/runtime/shaders/wgsl/fs_bokeh_forward.bin index a1e25d25d..4ea73807d 100644 Binary files a/examples/runtime/shaders/wgsl/fs_bokeh_forward.bin and b/examples/runtime/shaders/wgsl/fs_bokeh_forward.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_bump.bin b/examples/runtime/shaders/wgsl/fs_bump.bin index 757fed1ca..34ab63f90 100644 Binary files a/examples/runtime/shaders/wgsl/fs_bump.bin and b/examples/runtime/shaders/wgsl/fs_bump.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_deferred_geom.bin b/examples/runtime/shaders/wgsl/fs_deferred_geom.bin index c537adc0c..ef4926bc5 100644 Binary files a/examples/runtime/shaders/wgsl/fs_deferred_geom.bin and b/examples/runtime/shaders/wgsl/fs_deferred_geom.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_deferred_light.bin b/examples/runtime/shaders/wgsl/fs_deferred_light.bin index b13d602e9..987dcdc6b 100644 Binary files a/examples/runtime/shaders/wgsl/fs_deferred_light.bin and b/examples/runtime/shaders/wgsl/fs_deferred_light.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_deferred_light_ta.bin b/examples/runtime/shaders/wgsl/fs_deferred_light_ta.bin index 2e9d59616..0b2cc531e 100644 Binary files a/examples/runtime/shaders/wgsl/fs_deferred_light_ta.bin and b/examples/runtime/shaders/wgsl/fs_deferred_light_ta.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_deferred_light_uav.bin b/examples/runtime/shaders/wgsl/fs_deferred_light_uav.bin index cc7d7b7f6..aeecb1f7b 100644 Binary files a/examples/runtime/shaders/wgsl/fs_deferred_light_uav.bin and b/examples/runtime/shaders/wgsl/fs_deferred_light_uav.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_denoise_gbuffer.bin b/examples/runtime/shaders/wgsl/fs_denoise_gbuffer.bin index 3f368ea17..11155ddbe 100644 Binary files a/examples/runtime/shaders/wgsl/fs_denoise_gbuffer.bin and b/examples/runtime/shaders/wgsl/fs_denoise_gbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_fsr_forward.bin b/examples/runtime/shaders/wgsl/fs_fsr_forward.bin index a1e25d25d..4ea73807d 100644 Binary files a/examples/runtime/shaders/wgsl/fs_fsr_forward.bin and b/examples/runtime/shaders/wgsl/fs_fsr_forward.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_hdr_mesh.bin b/examples/runtime/shaders/wgsl/fs_hdr_mesh.bin index 955445542..0aaaec063 100644 Binary files a/examples/runtime/shaders/wgsl/fs_hdr_mesh.bin and b/examples/runtime/shaders/wgsl/fs_hdr_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_hdr_skybox.bin b/examples/runtime/shaders/wgsl/fs_hdr_skybox.bin index f3e347019..6555cf462 100644 Binary files a/examples/runtime/shaders/wgsl/fs_hdr_skybox.bin and b/examples/runtime/shaders/wgsl/fs_hdr_skybox.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_hextile.bin b/examples/runtime/shaders/wgsl/fs_hextile.bin index 2fd63b670..ee8b14bb0 100644 Binary files a/examples/runtime/shaders/wgsl/fs_hextile.bin and b/examples/runtime/shaders/wgsl/fs_hextile.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_ibl_mesh.bin b/examples/runtime/shaders/wgsl/fs_ibl_mesh.bin index b08d5a93e..7c295b8eb 100644 Binary files a/examples/runtime/shaders/wgsl/fs_ibl_mesh.bin and b/examples/runtime/shaders/wgsl/fs_ibl_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_mesh.bin b/examples/runtime/shaders/wgsl/fs_mesh.bin index 994f42bb2..a85a9a092 100644 Binary files a/examples/runtime/shaders/wgsl/fs_mesh.bin and b/examples/runtime/shaders/wgsl/fs_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_raymarching.bin b/examples/runtime/shaders/wgsl/fs_raymarching.bin index be485c654..15c527bfd 100644 Binary files a/examples/runtime/shaders/wgsl/fs_raymarching.bin and b/examples/runtime/shaders/wgsl/fs_raymarching.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_rsm_combine.bin b/examples/runtime/shaders/wgsl/fs_rsm_combine.bin index 92c267d4f..f4a801a8f 100644 Binary files a/examples/runtime/shaders/wgsl/fs_rsm_combine.bin and b/examples/runtime/shaders/wgsl/fs_rsm_combine.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_rsm_lbuffer.bin b/examples/runtime/shaders/wgsl/fs_rsm_lbuffer.bin index acbd2f4e1..e51ec9b58 100644 Binary files a/examples/runtime/shaders/wgsl/fs_rsm_lbuffer.bin and b/examples/runtime/shaders/wgsl/fs_rsm_lbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_screen_space_shadows.bin b/examples/runtime/shaders/wgsl/fs_screen_space_shadows.bin index ea0377a50..d872ab0ed 100644 Binary files a/examples/runtime/shaders/wgsl/fs_screen_space_shadows.bin and b/examples/runtime/shaders/wgsl/fs_screen_space_shadows.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm.bin index b7d5da0df..b636df817 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_csm.bin index fe9414dd3..152c9e393 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear.bin index 8aaa76e4f..92d3ca358 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_csm.bin index 87544c89c..5ed395cb4 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_omni.bin index ab7abdb4e..62b8466c2 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_linear_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_omni.bin index 400db79eb..0fb29abab 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_esm_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard.bin index 6dc7aece2..472e392ba 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_csm.bin index 367535e05..f373702f2 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear.bin index f41a1e668..1fe072e98 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_csm.bin index b80f5f18a..4e93234ce 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_omni.bin index 17cfedd90..ba9e7c13f 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_linear_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_omni.bin index 480136032..534f90637 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_hard_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf.bin index a75459f07..07d7e40b5 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_csm.bin index d6e2b1037..e73dfcc38 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear.bin index 9b0c11b2e..10fd0a24e 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_csm.bin index 15bb0373d..923a499a1 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_omni.bin index 666cc38f6..ae0ea9cab 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_linear_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_omni.bin index c727ff26f..e71d1ac9a 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcf_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss.bin index a6d162746..955a2c751 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_csm.bin index 022e41b61..cb999d61b 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear.bin index e1fbe54b7..7ea98dd80 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_csm.bin index b9a1d3d86..53688b47b 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_omni.bin index 0297fefe9..830aa2031 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_linear_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_omni.bin index bce800f42..b85917c1e 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_pcss_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm.bin index 9ae435ab7..cbee63f00 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_csm.bin index befc44282..b34e04f72 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear.bin index 0c997f1f6..6bed1946d 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_csm.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_csm.bin index bf970d405..2f2f3b4fc 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_csm.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_omni.bin index 579fe02e9..ec10f2c3a 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_linear_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_omni.bin b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_omni.bin index 5856b2da4..e88ccc61b 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_omni.bin and b/examples/runtime/shaders/wgsl/fs_shadowmaps_color_lighting_vsm_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_color_lighting.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_color_lighting.bin index 44fcacf57..363f4f41d 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_color_lighting.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_color_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex1.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex1.bin index 2167d94a2..f8a0ca781 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex1.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex1.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex2.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex2.bin index 4ab1479c2..aa72fa4e2 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex2.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_svbacktex2.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex1.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex1.bin index 27eeaf9aa..c3c52471e 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex1.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex1.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex2.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex2.bin index 0f0530b38..d26473dfd 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex2.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_svfronttex2.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_svside.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_svside.bin index be011ccbe..03033b3f1 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_svside.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_svside.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_svsidetex.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_svsidetex.bin index 66125c057..eda6314d3 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_svsidetex.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_svsidetex.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_shadowvolume_texture_lighting.bin b/examples/runtime/shaders/wgsl/fs_shadowvolume_texture_lighting.bin index 9ac0602de..5d6e8c801 100644 Binary files a/examples/runtime/shaders/wgsl/fs_shadowvolume_texture_lighting.bin and b/examples/runtime/shaders/wgsl/fs_shadowvolume_texture_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_sky_color_banding_fix.bin b/examples/runtime/shaders/wgsl/fs_sky_color_banding_fix.bin index 2b2ffbbc6..13d563ae1 100644 Binary files a/examples/runtime/shaders/wgsl/fs_sky_color_banding_fix.bin and b/examples/runtime/shaders/wgsl/fs_sky_color_banding_fix.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_sky_landscape.bin b/examples/runtime/shaders/wgsl/fs_sky_landscape.bin index 4d881d654..1ec0be845 100644 Binary files a/examples/runtime/shaders/wgsl/fs_sky_landscape.bin and b/examples/runtime/shaders/wgsl/fs_sky_landscape.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_sss_deferred_combine.bin b/examples/runtime/shaders/wgsl/fs_sss_deferred_combine.bin index 298b713bd..f080c35c4 100644 Binary files a/examples/runtime/shaders/wgsl/fs_sss_deferred_combine.bin and b/examples/runtime/shaders/wgsl/fs_sss_deferred_combine.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_sss_gbuffer.bin b/examples/runtime/shaders/wgsl/fs_sss_gbuffer.bin index 0b71b17b2..afc0a6ade 100644 Binary files a/examples/runtime/shaders/wgsl/fs_sss_gbuffer.bin and b/examples/runtime/shaders/wgsl/fs_sss_gbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_stencil_color_lighting.bin b/examples/runtime/shaders/wgsl/fs_stencil_color_lighting.bin index 3e19d79db..78110b39e 100644 Binary files a/examples/runtime/shaders/wgsl/fs_stencil_color_lighting.bin and b/examples/runtime/shaders/wgsl/fs_stencil_color_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/fs_stencil_texture_lighting.bin b/examples/runtime/shaders/wgsl/fs_stencil_texture_lighting.bin index bf76ea6cc..5d1733230 100644 Binary files a/examples/runtime/shaders/wgsl/fs_stencil_texture_lighting.bin and b/examples/runtime/shaders/wgsl/fs_stencil_texture_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_albedo_output.bin b/examples/runtime/shaders/wgsl/vs_albedo_output.bin index 6ccf2ff43..ae6a21806 100644 Binary files a/examples/runtime/shaders/wgsl/vs_albedo_output.bin and b/examples/runtime/shaders/wgsl/vs_albedo_output.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_assao.bin b/examples/runtime/shaders/wgsl/vs_assao.bin index 896db3288..2ee9c9ab4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_assao.bin and b/examples/runtime/shaders/wgsl/vs_assao.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_assao_gbuffer.bin b/examples/runtime/shaders/wgsl/vs_assao_gbuffer.bin index 679d0f6a0..b913b096c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_assao_gbuffer.bin and b/examples/runtime/shaders/wgsl/vs_assao_gbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_bokeh_forward.bin b/examples/runtime/shaders/wgsl/vs_bokeh_forward.bin index 8cb520128..99af34d47 100644 Binary files a/examples/runtime/shaders/wgsl/vs_bokeh_forward.bin and b/examples/runtime/shaders/wgsl/vs_bokeh_forward.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_bokeh_screenquad.bin b/examples/runtime/shaders/wgsl/vs_bokeh_screenquad.bin index 896db3288..2ee9c9ab4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_bokeh_screenquad.bin and b/examples/runtime/shaders/wgsl/vs_bokeh_screenquad.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_bump.bin b/examples/runtime/shaders/wgsl/vs_bump.bin index 8f7ce907f..875f4aae9 100644 Binary files a/examples/runtime/shaders/wgsl/vs_bump.bin and b/examples/runtime/shaders/wgsl/vs_bump.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_bump_instanced.bin b/examples/runtime/shaders/wgsl/vs_bump_instanced.bin index 93926f315..1125fffa1 100644 Binary files a/examples/runtime/shaders/wgsl/vs_bump_instanced.bin and b/examples/runtime/shaders/wgsl/vs_bump_instanced.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_bunnylod.bin b/examples/runtime/shaders/wgsl/vs_bunnylod.bin index a7dfdea3e..5b5dbb05b 100644 Binary files a/examples/runtime/shaders/wgsl/vs_bunnylod.bin and b/examples/runtime/shaders/wgsl/vs_bunnylod.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_callback.bin b/examples/runtime/shaders/wgsl/vs_callback.bin index 9495c0b40..27b9c81b1 100644 Binary files a/examples/runtime/shaders/wgsl/vs_callback.bin and b/examples/runtime/shaders/wgsl/vs_callback.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_cubes.bin b/examples/runtime/shaders/wgsl/vs_cubes.bin index cf34b8f49..0e8c50e36 100644 Binary files a/examples/runtime/shaders/wgsl/vs_cubes.bin and b/examples/runtime/shaders/wgsl/vs_cubes.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_deferred_combine.bin b/examples/runtime/shaders/wgsl/vs_deferred_combine.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_deferred_combine.bin and b/examples/runtime/shaders/wgsl/vs_deferred_combine.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_deferred_debug.bin b/examples/runtime/shaders/wgsl/vs_deferred_debug.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_deferred_debug.bin and b/examples/runtime/shaders/wgsl/vs_deferred_debug.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_deferred_debug_line.bin b/examples/runtime/shaders/wgsl/vs_deferred_debug_line.bin index cf34b8f49..0e8c50e36 100644 Binary files a/examples/runtime/shaders/wgsl/vs_deferred_debug_line.bin and b/examples/runtime/shaders/wgsl/vs_deferred_debug_line.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_deferred_geom.bin b/examples/runtime/shaders/wgsl/vs_deferred_geom.bin index d754797eb..47e4ae61c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_deferred_geom.bin and b/examples/runtime/shaders/wgsl/vs_deferred_geom.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_deferred_light.bin b/examples/runtime/shaders/wgsl/vs_deferred_light.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_deferred_light.bin and b/examples/runtime/shaders/wgsl/vs_deferred_light.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_denoise_gbuffer.bin b/examples/runtime/shaders/wgsl/vs_denoise_gbuffer.bin index 85ea86e2d..c2d5a6f9a 100644 Binary files a/examples/runtime/shaders/wgsl/vs_denoise_gbuffer.bin and b/examples/runtime/shaders/wgsl/vs_denoise_gbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_denoise_screenquad.bin b/examples/runtime/shaders/wgsl/vs_denoise_screenquad.bin index 896db3288..2ee9c9ab4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_denoise_screenquad.bin and b/examples/runtime/shaders/wgsl/vs_denoise_screenquad.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_fsr_forward.bin b/examples/runtime/shaders/wgsl/vs_fsr_forward.bin index 4b72f85dc..31fbdfde5 100644 Binary files a/examples/runtime/shaders/wgsl/vs_fsr_forward.bin and b/examples/runtime/shaders/wgsl/vs_fsr_forward.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_fsr_screenquad.bin b/examples/runtime/shaders/wgsl/vs_fsr_screenquad.bin index 896db3288..2ee9c9ab4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_fsr_screenquad.bin and b/examples/runtime/shaders/wgsl/vs_fsr_screenquad.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_fullscreen.bin b/examples/runtime/shaders/wgsl/vs_fullscreen.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_fullscreen.bin and b/examples/runtime/shaders/wgsl/vs_fullscreen.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_gdr_instanced_indirect_rendering.bin b/examples/runtime/shaders/wgsl/vs_gdr_instanced_indirect_rendering.bin index 934b8e4d7..1331cbb63 100644 Binary files a/examples/runtime/shaders/wgsl/vs_gdr_instanced_indirect_rendering.bin and b/examples/runtime/shaders/wgsl/vs_gdr_instanced_indirect_rendering.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_gdr_render_occlusion.bin b/examples/runtime/shaders/wgsl/vs_gdr_render_occlusion.bin index 7978169d4..3626c09d7 100644 Binary files a/examples/runtime/shaders/wgsl/vs_gdr_render_occlusion.bin and b/examples/runtime/shaders/wgsl/vs_gdr_render_occlusion.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_blur.bin b/examples/runtime/shaders/wgsl/vs_hdr_blur.bin index e88e3c275..fd865add4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_blur.bin and b/examples/runtime/shaders/wgsl/vs_hdr_blur.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_bright.bin b/examples/runtime/shaders/wgsl/vs_hdr_bright.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_bright.bin and b/examples/runtime/shaders/wgsl/vs_hdr_bright.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_lum.bin b/examples/runtime/shaders/wgsl/vs_hdr_lum.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_lum.bin and b/examples/runtime/shaders/wgsl/vs_hdr_lum.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_lumavg.bin b/examples/runtime/shaders/wgsl/vs_hdr_lumavg.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_lumavg.bin and b/examples/runtime/shaders/wgsl/vs_hdr_lumavg.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_mesh.bin b/examples/runtime/shaders/wgsl/vs_hdr_mesh.bin index 79d59737f..c1b470135 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_mesh.bin and b/examples/runtime/shaders/wgsl/vs_hdr_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_skybox.bin b/examples/runtime/shaders/wgsl/vs_hdr_skybox.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_skybox.bin and b/examples/runtime/shaders/wgsl/vs_hdr_skybox.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hdr_tonemap.bin b/examples/runtime/shaders/wgsl/vs_hdr_tonemap.bin index 9daa75e96..49b344e10 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hdr_tonemap.bin and b/examples/runtime/shaders/wgsl/vs_hdr_tonemap.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_hextile.bin b/examples/runtime/shaders/wgsl/vs_hextile.bin index de24d8381..3e4266989 100644 Binary files a/examples/runtime/shaders/wgsl/vs_hextile.bin and b/examples/runtime/shaders/wgsl/vs_hextile.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_ibl_mesh.bin b/examples/runtime/shaders/wgsl/vs_ibl_mesh.bin index 34b5c6a64..0496467d4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_ibl_mesh.bin and b/examples/runtime/shaders/wgsl/vs_ibl_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_ibl_skybox.bin b/examples/runtime/shaders/wgsl/vs_ibl_skybox.bin index 50473586e..cd55f4ca3 100644 Binary files a/examples/runtime/shaders/wgsl/vs_ibl_skybox.bin and b/examples/runtime/shaders/wgsl/vs_ibl_skybox.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_instancing.bin b/examples/runtime/shaders/wgsl/vs_instancing.bin index f266843f7..cfe7d7c9b 100644 Binary files a/examples/runtime/shaders/wgsl/vs_instancing.bin and b/examples/runtime/shaders/wgsl/vs_instancing.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_mesh.bin b/examples/runtime/shaders/wgsl/vs_mesh.bin index f3f8aaaba..6d1b667b6 100644 Binary files a/examples/runtime/shaders/wgsl/vs_mesh.bin and b/examples/runtime/shaders/wgsl/vs_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_oit.bin b/examples/runtime/shaders/wgsl/vs_oit.bin index d31941f8a..a3d3bb570 100644 Binary files a/examples/runtime/shaders/wgsl/vs_oit.bin and b/examples/runtime/shaders/wgsl/vs_oit.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_oit_blit.bin b/examples/runtime/shaders/wgsl/vs_oit_blit.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_oit_blit.bin and b/examples/runtime/shaders/wgsl/vs_oit_blit.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_particle.bin b/examples/runtime/shaders/wgsl/vs_particle.bin index b53754f82..5bbd68a1f 100644 Binary files a/examples/runtime/shaders/wgsl/vs_particle.bin and b/examples/runtime/shaders/wgsl/vs_particle.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_picking_shaded.bin b/examples/runtime/shaders/wgsl/vs_picking_shaded.bin index f829c964c..24ca3f009 100644 Binary files a/examples/runtime/shaders/wgsl/vs_picking_shaded.bin and b/examples/runtime/shaders/wgsl/vs_picking_shaded.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_pom.bin b/examples/runtime/shaders/wgsl/vs_pom.bin index c168dfe3a..f71ac2567 100644 Binary files a/examples/runtime/shaders/wgsl/vs_pom.bin and b/examples/runtime/shaders/wgsl/vs_pom.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_raymarching.bin b/examples/runtime/shaders/wgsl/vs_raymarching.bin index c7fd30e90..6320c1cff 100644 Binary files a/examples/runtime/shaders/wgsl/vs_raymarching.bin and b/examples/runtime/shaders/wgsl/vs_raymarching.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_rsm_combine.bin b/examples/runtime/shaders/wgsl/vs_rsm_combine.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_rsm_combine.bin and b/examples/runtime/shaders/wgsl/vs_rsm_combine.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_rsm_gbuffer.bin b/examples/runtime/shaders/wgsl/vs_rsm_gbuffer.bin index e6c952f16..7c13d53df 100644 Binary files a/examples/runtime/shaders/wgsl/vs_rsm_gbuffer.bin and b/examples/runtime/shaders/wgsl/vs_rsm_gbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_rsm_lbuffer.bin b/examples/runtime/shaders/wgsl/vs_rsm_lbuffer.bin index cd573e472..0d41b14e7 100644 Binary files a/examples/runtime/shaders/wgsl/vs_rsm_lbuffer.bin and b/examples/runtime/shaders/wgsl/vs_rsm_lbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_rsm_shadow.bin b/examples/runtime/shaders/wgsl/vs_rsm_shadow.bin index 2cd3dabef..064fa11dd 100644 Binary files a/examples/runtime/shaders/wgsl/vs_rsm_shadow.bin and b/examples/runtime/shaders/wgsl/vs_rsm_shadow.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color.bin index 07fbaac3d..bd7a92dcf 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting.bin index 6b255c71c..9c3c084f7 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_csm.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_csm.bin index 9fa20c229..c2cd5fd42 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_csm.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear.bin index cabd48cec..013b0e302 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_csm.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_csm.bin index 99ea7f95d..e584e7c29 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_csm.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_csm.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_omni.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_omni.bin index 23b1c9c3c..f32bba075 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_omni.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_linear_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_omni.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_omni.bin index 1932d73b9..96e0b162a 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_omni.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_lighting_omni.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_texture.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_texture.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_color_texture.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_color_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_depth.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_depth.bin index 07fbaac3d..bd7a92dcf 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_depth.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_depth.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_hblur.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_hblur.bin index 524f7fd3f..9ac05bad6 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_hblur.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_hblur.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth.bin index 45a9dad5c..c7d9c60be 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth_linear.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth_linear.bin index 3f930e9ac..9d2f6e559 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth_linear.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_packdepth_linear.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_texture.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_texture.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_texture.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_texture_lighting.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_texture_lighting.bin index 7766e5552..87f15bdda 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_texture_lighting.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_texture_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_unpackdepth.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_unpackdepth.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_unpackdepth.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_unpackdepth.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowmaps_vblur.bin b/examples/runtime/shaders/wgsl/vs_shadowmaps_vblur.bin index 79b3ae624..15f230be1 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowmaps_vblur.bin and b/examples/runtime/shaders/wgsl/vs_shadowmaps_vblur.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_color_lighting.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_color_lighting.bin index c21229d06..8e15d1bec 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_color_lighting.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_color_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_color_texture.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_color_texture.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_color_texture.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_color_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_svback.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_svback.bin index 343d6c3fa..affe6a3b1 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_svback.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_svback.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_svfront.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_svfront.bin index 07fbaac3d..bd7a92dcf 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_svfront.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_svfront.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_svside.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_svside.bin index c71841ed7..4cba30c55 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_svside.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_svside.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_texture.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_texture.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_texture.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_shadowvolume_texture_lighting.bin b/examples/runtime/shaders/wgsl/vs_shadowvolume_texture_lighting.bin index 7766e5552..87f15bdda 100644 Binary files a/examples/runtime/shaders/wgsl/vs_shadowvolume_texture_lighting.bin and b/examples/runtime/shaders/wgsl/vs_shadowvolume_texture_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sky.bin b/examples/runtime/shaders/wgsl/vs_sky.bin index aabe8e6c4..f7a5cc1aa 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sky.bin and b/examples/runtime/shaders/wgsl/vs_sky.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sky_landscape.bin b/examples/runtime/shaders/wgsl/vs_sky_landscape.bin index 8b603f02c..801cc82d6 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sky_landscape.bin and b/examples/runtime/shaders/wgsl/vs_sky_landscape.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sms_mesh.bin b/examples/runtime/shaders/wgsl/vs_sms_mesh.bin index 71cc24f3f..70ab2776e 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sms_mesh.bin and b/examples/runtime/shaders/wgsl/vs_sms_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sms_shadow.bin b/examples/runtime/shaders/wgsl/vs_sms_shadow.bin index 07fbaac3d..bd7a92dcf 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sms_shadow.bin and b/examples/runtime/shaders/wgsl/vs_sms_shadow.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sms_shadow_pd.bin b/examples/runtime/shaders/wgsl/vs_sms_shadow_pd.bin index 45a9dad5c..c7d9c60be 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sms_shadow_pd.bin and b/examples/runtime/shaders/wgsl/vs_sms_shadow_pd.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sss_gbuffer.bin b/examples/runtime/shaders/wgsl/vs_sss_gbuffer.bin index dc844ae70..99001377a 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sss_gbuffer.bin and b/examples/runtime/shaders/wgsl/vs_sss_gbuffer.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_sss_screenquad.bin b/examples/runtime/shaders/wgsl/vs_sss_screenquad.bin index 896db3288..2ee9c9ab4 100644 Binary files a/examples/runtime/shaders/wgsl/vs_sss_screenquad.bin and b/examples/runtime/shaders/wgsl/vs_sss_screenquad.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_stencil_color.bin b/examples/runtime/shaders/wgsl/vs_stencil_color.bin index 07fbaac3d..bd7a92dcf 100644 Binary files a/examples/runtime/shaders/wgsl/vs_stencil_color.bin and b/examples/runtime/shaders/wgsl/vs_stencil_color.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_stencil_color_lighting.bin b/examples/runtime/shaders/wgsl/vs_stencil_color_lighting.bin index 9fbdc3c7c..177bce04b 100644 Binary files a/examples/runtime/shaders/wgsl/vs_stencil_color_lighting.bin and b/examples/runtime/shaders/wgsl/vs_stencil_color_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_stencil_color_texture.bin b/examples/runtime/shaders/wgsl/vs_stencil_color_texture.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_stencil_color_texture.bin and b/examples/runtime/shaders/wgsl/vs_stencil_color_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_stencil_texture.bin b/examples/runtime/shaders/wgsl/vs_stencil_texture.bin index 97f97d2e2..ad17a0d4c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_stencil_texture.bin and b/examples/runtime/shaders/wgsl/vs_stencil_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_stencil_texture_lighting.bin b/examples/runtime/shaders/wgsl/vs_stencil_texture_lighting.bin index 7766e5552..87f15bdda 100644 Binary files a/examples/runtime/shaders/wgsl/vs_stencil_texture_lighting.bin and b/examples/runtime/shaders/wgsl/vs_stencil_texture_lighting.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_terrain.bin b/examples/runtime/shaders/wgsl/vs_terrain.bin index 6f06ad292..ab76ca2d6 100644 Binary files a/examples/runtime/shaders/wgsl/vs_terrain.bin and b/examples/runtime/shaders/wgsl/vs_terrain.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_terrain_height_texture.bin b/examples/runtime/shaders/wgsl/vs_terrain_height_texture.bin index f0d87f191..992e410b1 100644 Binary files a/examples/runtime/shaders/wgsl/vs_terrain_height_texture.bin and b/examples/runtime/shaders/wgsl/vs_terrain_height_texture.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_terrain_render.bin b/examples/runtime/shaders/wgsl/vs_terrain_render.bin index 01c313224..f9fc14147 100644 Binary files a/examples/runtime/shaders/wgsl/vs_terrain_render.bin and b/examples/runtime/shaders/wgsl/vs_terrain_render.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_tree.bin b/examples/runtime/shaders/wgsl/vs_tree.bin index 5db955630..550f1b519 100644 Binary files a/examples/runtime/shaders/wgsl/vs_tree.bin and b/examples/runtime/shaders/wgsl/vs_tree.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_update.bin b/examples/runtime/shaders/wgsl/vs_update.bin index 8b8528657..ab7ed40e3 100644 Binary files a/examples/runtime/shaders/wgsl/vs_update.bin and b/examples/runtime/shaders/wgsl/vs_update.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_vectordisplay_fb.bin b/examples/runtime/shaders/wgsl/vs_vectordisplay_fb.bin index c7fd30e90..6320c1cff 100644 Binary files a/examples/runtime/shaders/wgsl/vs_vectordisplay_fb.bin and b/examples/runtime/shaders/wgsl/vs_vectordisplay_fb.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_vt_generic.bin b/examples/runtime/shaders/wgsl/vs_vt_generic.bin index 0fad127a0..4710b1882 100644 Binary files a/examples/runtime/shaders/wgsl/vs_vt_generic.bin and b/examples/runtime/shaders/wgsl/vs_vt_generic.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_wf_mesh.bin b/examples/runtime/shaders/wgsl/vs_wf_mesh.bin index e0564017b..123bd65ef 100644 Binary files a/examples/runtime/shaders/wgsl/vs_wf_mesh.bin and b/examples/runtime/shaders/wgsl/vs_wf_mesh.bin differ diff --git a/examples/runtime/shaders/wgsl/vs_wf_wireframe.bin b/examples/runtime/shaders/wgsl/vs_wf_wireframe.bin index b94f6f04b..77b4b155c 100644 Binary files a/examples/runtime/shaders/wgsl/vs_wf_wireframe.bin and b/examples/runtime/shaders/wgsl/vs_wf_wireframe.bin differ diff --git a/scripts/shaderc.lua b/scripts/shaderc.lua index cca6d5a8c..97d44993d 100644 --- a/scripts/shaderc.lua +++ b/scripts/shaderc.lua @@ -56,6 +56,11 @@ project "tint-core" path.join(TINT, "src/tint/lang/null/**.h"), } + configuration { "osx*" } + buildoptions { + "-Wno-unknown-warning-option", + } + project "tint-lang" kind "StaticLib" @@ -96,6 +101,11 @@ project "tint-lang" path.join(TINT, "src/tint/lang/wgsl/**.h"), } + configuration { "osx*" } + buildoptions { + "-Wno-unknown-warning-option", + } + project "tint-api" kind "StaticLib" @@ -134,6 +144,11 @@ project "tint-api" path.join(TINT, "src/tint/api/**.h"), } + configuration { "osx*" } + buildoptions { + "-Wno-unknown-warning-option", + } + project "spirv-opt" kind "StaticLib" @@ -287,6 +302,13 @@ project "spirv-cross" "-Wno-type-limits", } + + configuration { "osx*" } + buildoptions { + "-Wno-deprecated-this-capture", + "-Wno-nan-infinity-disabled", + } + configuration {} project "glslang" diff --git a/src/bgfx_shader.sh b/src/bgfx_shader.sh index e98ac3c80..46126c8f5 100644 --- a/src/bgfx_shader.sh +++ b/src/bgfx_shader.sh @@ -24,7 +24,6 @@ #define BGFX_SHADER_MATRIX_COLUMN_MAJOR (0 \ || BGFX_SHADER_LANGUAGE_GLSL \ - || BGFX_SHADER_LANGUAGE_WGSL \ ) #if BGFX_SHADER_TYPE_FRAGMENT @@ -681,7 +680,7 @@ uvec4 uvec4_splat(uint _x) { return uvec4(_x, _x, _x, _x); } #if BGFX_SHADER_LANGUAGE_GLSL # define mul(_a, _b) ( (_a) * (_b) ) -#elif BGFX_SHADER_LANGUAGE_WGSL +#elif BGFX_SHADER_LANGUAGE_WGSL && BGFX_SHADER_MATRIX_COLUMN_MAJOR # define mul(_a, _b) mul(_b, _a) # define mat3x4 float3x4 # define mat4x3 float4x3 diff --git a/src/renderer_webgpu.cpp b/src/renderer_webgpu.cpp index 517765a37..14fd4f32a 100644 --- a/src/renderer_webgpu.cpp +++ b/src/renderer_webgpu.cpp @@ -392,6 +392,8 @@ namespace bgfx { namespace wgpu { LANGUAGE_FEATURE(UniformBufferStandardLayout), true, false }, { LANGUAGE_FEATURE(SubgroupId), true, false }, { LANGUAGE_FEATURE(TextureAndSamplerLet), true, false }, + { LANGUAGE_FEATURE(SubgroupUniformity), true, false }, + { LANGUAGE_FEATURE(ImmediateAddressSpace), true, false }, { LANGUAGE_FEATURE(ChromiumTestingUnimplemented), true, false }, { LANGUAGE_FEATURE(ChromiumTestingUnsafeExperimental), true, false }, { LANGUAGE_FEATURE(ChromiumTestingExperimental), true, false }, @@ -401,8 +403,6 @@ namespace bgfx { namespace wgpu { LANGUAGE_FEATURE(TexelBuffers), true, false }, { LANGUAGE_FEATURE(ChromiumPrint), true, false }, { LANGUAGE_FEATURE(FragmentDepth), true, false }, - { LANGUAGE_FEATURE(ImmediateAddressSpace), true, false }, - { LANGUAGE_FEATURE(SubgroupUniformity), true, false }, #undef LANGUAGE_FEATURE };