Lines Matching defs:builder
80 SpecConstantOpModeGuard(spv::Builder* builder)
81 : builder_(builder) {
82 previous_flag_ = builder->isInSpecConstCodeGenMode();
108 void addNoContraction(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, noContraction); }
109 void addNonUniform(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, nonUniform); }
248 // There is a 1:1 mapping between a spv builder and a module; this is thread safe
249 spv::Builder builder;
482 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
499 builder.addCapability(spv::CapabilitySampleRateShading);
528 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
529 builder.addCapability(spv::CapabilityShaderNonUniformEXT);
540 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
541 builder.addCapability(spv::CapabilityShaderNonUniformEXT);
567 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
593 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
640 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
660 builder.addCapability(spv::CapabilityGeometryPointSize);
664 builder.addCapability(spv::CapabilityTessellationPointSize);
698 builder.addCapability(spv::CapabilityClipDistance);
703 builder.addCapability(spv::CapabilityCullDistance);
709 builder.addCapability(spv::CapabilityMultiViewport);
715 if (builder.getSpvVersion() < spv::Spv_1_5) {
716 builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);
717 builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT);
720 builder.addCapability(spv::CapabilityShaderViewportIndex);
725 builder.addCapability(spv::CapabilitySampleRateShading);
729 builder.addCapability(spv::CapabilitySampleRateShading);
741 builder.addCapability(spv::CapabilityGeometry);
747 if (builder.getSpvVersion() < spv::Spv_1_5) {
748 builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);
749 builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT);
751 builder.addCapability(spv::CapabilityShaderLayer);
756 builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
757 builder.addCapability(spv::CapabilityDrawParameters);
761 builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
762 builder.addCapability(spv::CapabilityDrawParameters);
766 builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
767 builder.addCapability(spv::CapabilityDrawParameters);
772 builder.addCapability(spv::CapabilityGeometry);
776 builder.addExtension(spv::E_SPV_EXT_shader_stencil_export);
777 builder.addCapability(spv::CapabilityStencilExportEXT);
781 builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);
782 builder.addCapability(spv::CapabilityFragmentShadingRateKHR);
786 builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);
787 builder.addCapability(spv::CapabilityFragmentShadingRateKHR);
798 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
799 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
803 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
804 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
808 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
809 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
813 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
814 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
818 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
819 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
823 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
824 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
828 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
829 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
833 builder.addCapability(spv::CapabilityGroupNonUniform);
837 builder.addCapability(spv::CapabilityGroupNonUniform);
841 builder.addCapability(spv::CapabilityGroupNonUniform);
845 builder.addCapability(spv::CapabilityGroupNonUniform);
849 builder.addCapability(spv::CapabilityGroupNonUniform);
850 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
854 builder.addCapability(spv::CapabilityGroupNonUniform);
855 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
859 builder.addCapability(spv::CapabilityGroupNonUniform);
860 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
864 builder.addCapability(spv::CapabilityGroupNonUniform);
865 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
869 builder.addCapability(spv::CapabilityGroupNonUniform);
870 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
874 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
878 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
882 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
886 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
890 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
894 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
898 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
902 builder.addIncorporatedExtension(spv::E_SPV_KHR_device_group, spv::Spv_1_3);
903 builder.addCapability(spv::CapabilityDeviceGroup);
907 builder.addIncorporatedExtension(spv::E_SPV_KHR_multiview, spv::Spv_1_3);
908 builder.addCapability(spv::CapabilityMultiView);
912 builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density);
913 builder.addCapability(spv::CapabilityFragmentDensityEXT);
917 builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density);
918 builder.addCapability(spv::CapabilityFragmentDensityEXT);
923 builder.addExtension(spv::E_SPV_NV_viewport_array2);
924 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
929 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
930 builder.addCapability(spv::CapabilityShaderStereoViewNV);
935 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
936 builder.addCapability(spv::CapabilityShaderStereoViewNV);
941 builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes);
942 builder.addCapability(spv::CapabilityPerViewAttributesNV);
947 builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes);
948 builder.addCapability(spv::CapabilityPerViewAttributesNV);
952 builder.addExtension(spv::E_SPV_EXT_fragment_fully_covered);
953 builder.addCapability(spv::CapabilityFragmentFullyCoveredEXT);
956 builder.addExtension(spv::E_SPV_NV_shading_rate);
957 builder.addCapability(spv::CapabilityShadingRateNV);
960 builder.addExtension(spv::E_SPV_NV_shading_rate);
961 builder.addCapability(spv::CapabilityShadingRateNV);
1012 builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
1013 builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
1016 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1017 builder.addExtension("SPV_NV_displacement_micromap");
1020 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1021 builder.addExtension("SPV_NV_displacement_micromap");
1024 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1025 builder.addExtension("SPV_NV_displacement_micromap");
1028 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1029 builder.addExtension("SPV_NV_displacement_micromap");
1034 builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
1035 builder.addCapability(spv::CapabilityFragmentBarycentricNV);
1038 builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
1039 builder.addCapability(spv::CapabilityFragmentBarycentricNV);
1043 builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
1044 builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
1047 builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
1048 builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
1081 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1082 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1085 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1086 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1089 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1090 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1093 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1094 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1099 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1100 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1103 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1104 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1107 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1108 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1111 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1112 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1115 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1116 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1159 builder.addCapability(spv::CapabilityStorageImageExtendedFormats);
1164 builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
1165 builder.addCapability(spv::CapabilityInt64ImageEXT);
1294 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1295 builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
1313 builder.addIncorporatedExtension(spv::E_SPV_KHR_storage_buffer_storage_class, spv::Spv_1_3);
1326 builder.addExtension(spv::E_SPV_KHR_workgroup_memory_explicit_layout);
1327 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayoutKHR);
1409 builder.addCapability(spv::CapabilityInputAttachmentArrayNonUniformIndexingEXT);
1411 builder.addCapability(spv::CapabilityStorageTexelBufferArrayNonUniformIndexingEXT);
1413 builder.addCapability(spv::CapabilityUniformTexelBufferArrayNonUniformIndexingEXT);
1415 builder.addCapability(spv::CapabilityStorageImageArrayNonUniformIndexingEXT);
1417 builder.addCapability(spv::CapabilitySampledImageArrayNonUniformIndexingEXT);
1420 builder.addCapability(spv::CapabilityStorageBufferArrayNonUniformIndexingEXT);
1422 builder.addCapability(spv::CapabilityUniformBufferArrayNonUniformIndexingEXT);
1428 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1429 builder.addCapability(spv::CapabilityInputAttachmentArrayDynamicIndexingEXT);
1431 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1432 builder.addCapability(spv::CapabilityStorageTexelBufferArrayDynamicIndexingEXT);
1434 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1435 builder.addCapability(spv::CapabilityUniformTexelBufferArrayDynamicIndexingEXT);
1540 builder(spvVersion, (glslang::GetKhronosToolId() << 16) | glslang::GetSpirvGeneratorVersion(), logger),
1551 builder.clearAccessChain();
1552 builder.setSource(TranslateSourceLanguage(glslangIntermediate->getSource(), glslangIntermediate->getProfile()),
1561 builder.setEmitOpLines();
1562 builder.setSourceFile(glslangIntermediate->getSourceFile());
1575 builder.addModuleProcessed(processes[p]);
1580 builder.setSourceText(text);
1584 builder.addInclude(iItr->first, iItr->second);
1587 builder.setEmitNonSemanticShaderDebugInfo(this->options.emitNonSemanticShaderDebugInfo);
1588 builder.setEmitNonSemanticShaderDebugSource(this->options.emitNonSemanticShaderDebugSource);
1590 stdBuiltins = builder.import("GLSL.std.450");
1597 builder.addIncorporatedExtension(spv::E_SPV_KHR_physical_storage_buffer, spv::Spv_1_5);
1598 builder.addCapability(spv::CapabilityPhysicalStorageBufferAddressesEXT);
1602 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
1603 builder.addIncorporatedExtension(spv::E_SPV_KHR_vulkan_memory_model, spv::Spv_1_5);
1605 builder.setMemoryModel(addressingModel, memoryModel);
1608 builder.addCapability(spv::CapabilityVariablePointers);
1613 shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
1615 builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
1621 builder.addSourceExtension(it->c_str());
1626 builder.addCapability(spv::CapabilityTransformFeedback);
1627 builder.addExecutionMode(shaderEntry, spv::ExecutionModeXfb);
1631 builder.addCapability(spv::CapabilityRayTraversalPrimitiveCullingKHR);
1635 builder.addExtension(spv::E_SPV_KHR_subgroup_uniform_control_flow);
1636 builder.addExecutionMode(shaderEntry, spv::ExecutionModeSubgroupUniformControlFlowKHR);
1642 builder.addCapability(spv::CapabilityShader);
1646 builder.addCapability(spv::CapabilityShader);
1648 builder.addExecutionMode(shaderEntry, spv::ExecutionModePixelCenterInteger);
1651 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginUpperLeft);
1653 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginLowerLeft);
1656 builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests);
1660 builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyAndLateFragmentTestsAMD);
1661 builder.addExtension(spv::E_SPV_AMD_shader_early_and_late_fragment_tests);
1665 builder.addCapability(spv::CapabilitySampleMaskPostDepthCoverage);
1666 builder.addExecutionMode(shaderEntry, spv::ExecutionModePostDepthCoverage);
1667 builder.addExtension(spv::E_SPV_KHR_post_depth_coverage);
1671 builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
1672 builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentColorAttachmentReadEXT);
1673 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1677 builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
1678 builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentDepthAttachmentReadEXT);
1679 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1683 builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
1684 builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentStencilAttachmentReadEXT);
1685 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1689 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
1692 builder.addExecutionMode(shaderEntry, spv::ExecutionModeStencilRefReplacingEXT);
1702 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1715 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1733 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1736 builder.addCapability(spv::CapabilityFragmentShaderShadingRateInterlockEXT);
1739 builder.addCapability(spv::CapabilityFragmentShaderPixelInterlockEXT);
1741 builder.addCapability(spv::CapabilityFragmentShaderSampleInterlockEXT);
1743 builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
1748 builder.addCapability(spv::CapabilityShader);
1760 dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
1762 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
1767 builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
1769 builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
1774 builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
1775 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV);
1776 builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
1778 builder.addCapability(spv::CapabilityComputeDerivativeGroupLinearNV);
1779 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupLinearNV);
1780 builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
1786 builder.addCapability(spv::CapabilityTessellation);
1791 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
1805 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1814 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1822 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1825 builder.addExecutionMode(shaderEntry, spv::ExecutionModePointMode);
1829 builder.addCapability(spv::CapabilityGeometry);
1839 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1841 builder.addExecutionMode(shaderEntry, spv::ExecutionModeInvocations, glslangIntermediate->getInvocations());
1850 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1851 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices());
1863 builder.addCapability(spv::CapabilityRayTracingKHR);
1864 builder.addExtension("SPV_KHR_ray_tracing");
1867 builder.addCapability(spv::CapabilityRayTracingNV);
1868 builder.addExtension("SPV_NV_ray_tracing");
1872 builder.addCapability(spv::CapabilityRayCullMaskKHR);
1873 builder.addExtension("SPV_KHR_ray_cull_mask");
1876 builder.addCapability(spv::CapabilityRayTracingPositionFetchKHR);
1877 builder.addExtension("SPV_KHR_ray_tracing_position_fetch");
1885 builder.addCapability(spv::CapabilityMeshShadingEXT);
1886 builder.addExtension(spv::E_SPV_EXT_mesh_shader);
1888 builder.addCapability(spv::CapabilityMeshShadingNV);
1889 builder.addExtension(spv::E_SPV_NV_mesh_shader);
1895 dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
1897 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
1901 builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
1903 builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
1908 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
1910 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV,
1920 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1936 builder.addExtension(extension.c_str());
1940 builder.addCapability(static_cast<spv::Capability>(capability));
1954 builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first), literals);
1956 builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first));
1969 builder.addExecutionModeId(shaderEntry, static_cast<spv::ExecutionMode>(modeId.first), operandIds);
1981 builder.setBuildPoint(shaderEntry->getLastBlock());
1982 builder.leaveFunction();
1994 builder.postProcess(compileOnly);
2000 builder.dump(out);
2022 builder.setLine(symbol->getLoc().line, symbol->getLoc().getFilename());
2024 SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2043 if (builder.isPointer(id)) {
2050 spv::StorageClass sc = builder.getStorageClass(id);
2053 if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalVariable(id)) ||
2077 builder.clearAccessChain();
2088 !builder.isPointerType(builder.getTypeId(id)))
2089 builder.setAccessChainRValue(id);
2091 builder.setAccessChainLValue(id);
2117 builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
2118 builder.addDecorationId(id, spv::DecorationHlslCounterBufferGOOGLE, counterId);
2131 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2139 SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2166 builder.clearAccessChain();
2168 spv::Builder::AccessChain lValue = builder.getAccessChain();
2171 builder.clearAccessChain();
2176 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2180 builder.setAccessChain(lValue);
2198 builder.setAccessChain(lValue);
2202 builder.clearAccessChain();
2203 builder.setAccessChainRValue(rValue);
2227 builder.accessChainPushSwizzle(swizzle, convertGlslangToSpvType(node->getLeft()->getType()),
2241 builder.clearAccessChain();
2242 builder.setAccessChainLValue(left);
2265 builder.accessChainPush(builder.makeIntConstant(spvIndex),
2288 spv::Builder::AccessChain partial = builder.getAccessChain();
2291 builder.clearAccessChain();
2298 builder.setAccessChain(partial);
2307 builder.accessChainPushComponent(
2312 builder.accessChainPush(index, coherent_flags,
2322 builder.accessChainPushSwizzle(swizzle, convertGlslangToSpvType(node->getLeft()->getType()),
2343 builder.clearAccessChain();
2344 builder.setAccessChainRValue(result);
2354 builder.clearAccessChain();
2359 builder.clearAccessChain();
2371 builder.clearAccessChain();
2376 builder.setAccessChainRValue(result);
2385 if (builder.isScalarType(nominalTypeId)) {
2387 spv::Id boolType = builder.makeBoolType();
2389 return builder.createBinOp(spv::OpINotEqual, boolType, loadedId, builder.makeUintConstant(0));
2390 } else if (builder.isVectorType(nominalTypeId)) {
2392 int vecSize = builder.getNumTypeComponents(nominalTypeId);
2393 spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
2395 loadedId = builder.createBinOp(spv::OpINotEqual, bvecType, loadedId,
2396 makeSmearedConstant(builder.makeUintConstant(0), vecSize));
2397 } else if (builder.isArrayType(nominalTypeId)) {
2404 return builder.createUnaryOp(spv::OpCopyLogical, boolArrayTypeId, loadedId);
2407 spv::Id elementNominalTypeId = builder.getContainedTypeId(nominalTypeId);
2411 spv::Id elementValue = builder.createCompositeExtract(loadedId, elementNominalTypeId, index);
2417 return builder.createCompositeConstruct(boolArrayTypeId, constituents);
2440 spv::Id ivec4_type = builder.makeVectorType(builder.makeUintType(32), 4);
2441 spv::Id uint64_type = builder.makeUintType(64);
2449 spv::Id mat43 = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
2450 spv::Id mat34 = builder.makeMatrixType(builder.makeFloatType(32), 3, 4);
2472 spv::Id objectTypeId = builder.getTypeId(object);
2473 assert(builder.isPointerType(objectTypeId));
2474 objectTypeId = builder.getContainedTypeId(objectTypeId);
2475 if (builder.isVectorType(objectTypeId) &&
2476 builder.getScalarTypeWidth(builder.getContainedTypeId(objectTypeId)) == 32) {
2477 if (builder.getScalarTypeWidth(desiredTypeId) == 64) {
2479 builder.clearAccessChain();
2480 builder.setAccessChainLValue(object);
2481 object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, spv::DecorationMax, objectTypeId);
2483 components.push_back(builder.createCompositeExtract(object, builder.getContainedTypeId(objectTypeId), 0));
2484 components.push_back(builder.createCompositeExtract(object, builder.getContainedTypeId(objectTypeId), 1));
2486 spv::Id vecType = builder.makeVectorType(builder.getContainedTypeId(objectTypeId), 2);
2487 return builder.createUnaryOp(spv::OpBitcast, desiredTypeId,
2488 builder.createCompositeConstruct(vecType, components));
2492 } else if (builder.isMatrixType(objectTypeId)) {
2495 builder.clearAccessChain();
2496 builder.setAccessChainLValue(object);
2497 object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, spv::DecorationMax, objectTypeId);
2498 return builder.createUnaryOp(spv::OpTranspose, desiredTypeId, object);
2509 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2511 SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2520 builder.clearAccessChain();
2521 builder.setAccessChainRValue(result);
2543 assert(builder.isCooperativeMatrixType(typeId));
2546 length = builder.createCooperativeMatrixLengthKHR(typeId);
2549 length = builder.createCooperativeMatrixLengthNV(typeId);
2556 length = builder.createArrayLength(builder.accessChainGetLValue(), member);
2563 if (builder.isInSpecConstCodeGenMode()) {
2564 length = builder.createBinOp(spv::OpIAdd, builder.makeIntType(32), length, builder.makeIntConstant(0));
2566 length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length);
2570 builder.clearAccessChain();
2571 builder.setAccessChainRValue(length);
2578 builder.clearAccessChain();
2580 builder.clearAccessChain();
2594 builder.clearAccessChain();
2651 operand = builder.accessChainGetLValue(); // Special case l-value operands
2652 lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
2691 builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), {idImmOp});
2693 result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), {idImmOp});
2695 result = builder.createBuiltinCall(
2708 decorations.addNonUniform(builder, result);
2711 builder.clearAccessChain();
2712 builder.setAccessChainRValue(result);
2727 one = builder.makeFloatConstant(1.0F);
2729 one = builder.makeDoubleConstant(1.0);
2731 one = builder.makeFloat16Constant(1.0F);
2733 one = builder.makeInt8Constant(1);
2735 one = builder.makeInt16Constant(1);
2737 one = builder.makeInt64Constant(1);
2739 one = builder.makeIntConstant(1);
2754 builder.accessChainStore(result,
2755 TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags));
2756 builder.clearAccessChain();
2759 builder.setAccessChainRValue(result);
2761 builder.setAccessChainRValue(operand);
2767 builder.createNoResultOp(spv::OpEmitStreamVertex, operand);
2770 builder.createNoResultOp(spv::OpEndStreamPrimitive, operand);
2773 builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operand);
2776 builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand);
2779 builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operand);
2782 builder.createNoResultOp(spv::OpHitObjectRecordEmptyNV, operand);
2796 spv::Id lType = builder.getContainedTypeId(resultTypeId, c);
2797 spv::Id rType = builder.getTypeId(constituent);
2800 constituent = builder.createUnaryOp(spv::OpCopyLogical, lType, constituent);
2801 } else if (builder.isStructType(rType)) {
2803 int numrTypeConstituents = builder.getNumTypeConstituents(rType);
2805 rTypeConstituents.push_back(builder.createCompositeExtract(constituent,
2806 builder.getContainedTypeId(rType, i), i));
2810 assert(builder.isArrayType(rType));
2812 int numrTypeConstituents = builder.getNumTypeConstituents(rType);
2814 spv::Id elementRType = builder.getContainedTypeId(rType);
2816 rTypeConstituents.push_back(builder.createCompositeExtract(constituent, elementRType, i));
2822 return builder.createCompositeConstruct(resultTypeId, constituents);
2827 SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2844 builder.clearAccessChain();
2845 builder.setAccessChainRValue(result);
2897 builder.enterScope(0);
2901 builder.leaveScope();
2930 builder.setBuildPoint(shaderEntry->getLastBlock());
2931 builder.enterFunction(shaderEntry);
2939 spv::Id sourceFileId = sourceFileName ? builder.getStringId(sourceFileName) : builder.getSourceFile();
2945 builder.leaveFunction();
2957 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2961 builder.clearAccessChain();
2962 builder.setAccessChainRValue(result);
3078 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3091 constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
3101 constructed = builder.createMatrixConstructor(precision, arguments, resultType());
3103 constructed = builder.createConstructor(precision, arguments, resultType());
3106 builder.addDecoration(constructed, spv::DecorationNonUniformEXT);
3109 builder.clearAccessChain();
3110 builder.setAccessChainRValue(constructed);
3208 builder.addExtension("SPV_KHR_shader_atomic_counter_ops");
3209 builder.addCapability(spv::CapabilityAtomicStorageOps);
3219 builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
3220 builder.addExtension("SPV_INTEL_shader_integer_functions2");
3240 builder.addExtension("SPV_KHR_ray_query");
3241 builder.addCapability(spv::CapabilityRayQueryKHR);
3263 builder.addExtension("SPV_KHR_ray_query");
3264 builder.addCapability(spv::CapabilityRayQueryKHR);
3274 builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
3311 builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
3312 builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
3315 builder.addExtension(spv::E_SPV_KHR_ray_tracing_position_fetch);
3316 builder.addCapability(spv::CapabilityRayQueryPositionFetchKHR);
3321 builder.addCapability(spv::CapabilityTextureSampleWeightedQCOM);
3322 builder.addExtension(spv::E_SPV_QCOM_image_processing);
3325 builder.addCapability(spv::CapabilityTextureBoxFilterQCOM);
3326 builder.addExtension(spv::E_SPV_QCOM_image_processing);
3330 builder.addCapability(spv::CapabilityTextureBlockMatchQCOM);
3331 builder.addExtension(spv::E_SPV_QCOM_image_processing);
3336 builder.addExtension(spv::E_SPV_NV_displacement_micromap);
3337 builder.addCapability(spv::CapabilityDisplacementMicromapNV);
3356 builder.clearAccessChain();
3360 builder.clearAccessChain();
3364 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3374 builder.clearAccessChain();
3375 builder.setAccessChainRValue(result);
3524 builder.clearAccessChain();
3537 spv::Builder::AccessChain save = builder.getAccessChain();
3538 builder.clearAccessChain();
3543 builder.setAccessChain(save);
3546 builder.accessChainPush(elementId,
3550 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
3551 unsigned int alignment = builder.getAccessChain().alignment;
3560 if (builder.getStorageClass(builder.getAccessChain().base) ==
3574 builder.makeUintConstant(TranslateMemoryScope(coherentFlags))));
3583 if (invertedType == spv::NoType && !builder.isSpvLvalue()) {
3588 complexLvalues.push_back(builder.getAccessChain());
3589 temporaryLvalues.push_back(builder.createVariable(
3591 builder.accessChainGetInferredType(), "swizzleTemp"));
3594 operands.push_back(builder.accessChainGetLValue());
3596 lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
3599 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3618 operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
3651 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3666 spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
3667 assert(builder.isCooperativeMatrixType(typeId));
3670 ? builder.createOp(spv::OpCooperativeMatrixLoadKHR, typeId, idImmOps)
3671 : builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps);
3673 builder.createStore(result, operands[0]);
3691 builder.createNoResultOp(spv::OpCooperativeMatrixStoreKHR, idImmOps);
3693 builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
3701 spv::Id typeId = builder.makeArrayType(builder.makeVectorType(builder.makeFloatType(32), 3),
3702 builder.makeUintConstant(3), 0);
3707 spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
3709 builder.createStore(result, operands[2]);
3736 result = builder.createOp(spv::OpCooperativeMatrixMulAddKHR, resultType(), idImmOps);
3760 builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), idImmOps);
3762 result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), idImmOps);
3764 result = builder.createBuiltinCall(
3771 nonSemanticDebugPrintf = builder.import("NonSemantic.DebugPrintf");
3773 result = builder.createBuiltinCall(builder.makeVoidType(), nonSemanticDebugPrintf, spv::NonSemanticDebugPrintfDebugPrintf, operands);
3774 builder.addExtension(spv::E_SPV_KHR_non_semantic_info);
3801 builder.setAccessChain(complexLvalues[i]);
3802 builder.accessChainStore(builder.createLoad(temporaryLvalues[i], spv::NoPrecision),
3814 builder.clearAccessChain();
3815 builder.setAccessChainRValue(result);
3891 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3905 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4 && builder.isVector(trueValue)) {
3906 condition = builder.smearScalar(spv::NoPrecision, condition,
3907 builder.makeVectorType(builder.makeBoolType(),
3908 builder.getNumComponents(trueValue)));
3914 if (builder.getTypeId(trueValue) != resultType) {
3915 trueValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, trueValue);
3917 if (builder.getTypeId(falseValue) != resultType) {
3918 falseValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, falseValue);
3922 result = builder.createTriOp(spv::OpSelect, resultType, condition, trueValue, falseValue);
3924 builder.clearAccessChain();
3925 builder.setAccessChainRValue(result);
3929 result = builder.createVariable(TranslatePrecisionDecoration(node->getType()),
3936 spv::Builder::If ifBuilder(condition, control, builder);
3939 builder.clearAccessChain();
3940 builder.setAccessChainLValue(result);
3945 builder.clearAccessChain();
3946 builder.setAccessChainLValue(result);
3952 builder.clearAccessChain();
3953 builder.setAccessChainLValue(result);
3961 result = builder.createVariable(TranslatePrecisionDecoration(node->getType()), spv::StorageClassFunction,
3969 spv::Builder::If ifBuilder(condition, control, builder);
3977 builder.clearAccessChain();
3978 builder.setAccessChainLValue(result);
3990 builder.clearAccessChain();
3991 builder.setAccessChainLValue(result);
4000 builder.clearAccessChain();
4001 builder.setAccessChainLValue(result);
4007 SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
4052 builder.makeSwitch(selector, control, (int)codeSegments.size(), caseValues, valueIndexToSegment, defaultSegment,
4058 builder.nextSwitchSegment(segmentBlocks, s);
4062 builder.addSwitchBreak();
4066 builder.endSwitch(segmentBlocks);
4079 builder.clearAccessChain();
4080 builder.setAccessChainRValue(constant);
4085 auto blocks = builder.makeNewLoop();
4086 builder.createBranch(&blocks.head);
4098 builder.setBuildPoint(&blocks.head);
4099 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
4100 builder.createLoopMerge(&blocks.merge, &blocks.continue_target, control, operands);
4102 spv::Block& test = builder.makeNewBlock();
4103 builder.createBranch(&test);
4105 builder.setBuildPoint(&test);
4108 builder.createConditionalBranch(condition, &blocks.body, &blocks.merge);
4110 builder.setBuildPoint(&blocks.body);
4114 builder.createBranch(&blocks.continue_target);
4117 builder.setBuildPoint(&blocks.continue_target);
4120 builder.createBranch(&blocks.head);
4122 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
4123 builder.createBranch(&blocks.body);
4126 builder.setBuildPoint(&blocks.body);
4129 builder.createBranch(&blocks.continue_target);
4132 builder.setBuildPoint(&blocks.continue_target);
4139 builder.createConditionalBranch(condition, &blocks.head, &blocks.merge);
4144 builder.createBranch(&blocks.head);
4147 builder.setBuildPoint(&blocks.merge);
4148 builder.closeLoop();
4157 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
4163 builder.addCapability(spv::CapabilityDemoteToHelperInvocation);
4164 builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
4166 builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
4169 builder.makeStatementTerminator(spv::OpKill, "post-discard");
4173 builder.addExtension(spv::E_SPV_KHR_terminate_invocation);
4174 builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
4178 builder.createLoopExit();
4180 builder.addSwitchBreak();
4183 builder.createLoopContinue();
4189 if (builder.getTypeId(returnId) != currentFunction->getReturnType() ||
4191 builder.clearAccessChain();
4192 spv::Id copyId = builder.createVariable(currentFunction->getReturnPrecision(),
4194 builder.setAccessChainLValue(copyId);
4196 returnId = builder.createLoad(copyId, currentFunction->getReturnPrecision());
4198 builder.makeReturn(false, returnId);
4200 builder.makeReturn(false);
4202 builder.clearAccessChain();
4206 builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
4207 builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
4208 builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT);
4211 builder.makeStatementTerminator(spv::OpTerminateRayKHR, "post-terminateRayKHR");
4214 builder.makeStatementTerminator(spv::OpIgnoreIntersectionKHR, "post-ignoreIntersectionKHR");
4247 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4248 builder.addCapability(spv::CapabilityStorageInputOutput16);
4251 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4253 builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
4255 builder.addCapability(spv::CapabilityStorageUniform16);
4258 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4259 builder.addCapability(spv::CapabilityStoragePushConstant16);
4263 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4264 builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
4269 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR);
4273 builder.addCapability(spv::CapabilityFloat16);
4275 builder.addCapability(spv::CapabilityInt16);
4282 builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4283 builder.addCapability(spv::CapabilityStoragePushConstant8);
4285 builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4286 builder.addCapability(spv::CapabilityUniformAndStorageBuffer8BitAccess);
4288 builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4289 builder.addCapability(spv::CapabilityStorageBuffer8BitAccess);
4292 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR);
4294 builder.addCapability(spv::CapabilityInt8);
4311 initializer = builder.makeNullConstant(spvType);
4314 return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer, false);
4321 case glslang::EbtInt: return builder.makeIntType(32);
4322 case glslang::EbtUint: return builder.makeUintType(32);
4323 case glslang::EbtFloat: return builder.makeFloatType(32);
4325 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float_fetch);
4326 builder.addCapability(spv::CapabilityFloat16ImageAMD);
4327 return builder.makeFloatType(16);
4329 builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
4330 builder.addCapability(spv::CapabilityInt64ImageEXT);
4331 return builder.makeIntType(64);
4333 builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
4334 builder.addCapability(spv::CapabilityInt64ImageEXT);
4335 return builder.makeUintType(64);
4338 return builder.makeFloatType(32);
4361 return builder.createRvalueSwizzle(precision, convertGlslangToSpvType(node.getType()), parentResult, swizzle);
4401 spvType = builder.makeVoidType();
4408 spvType = builder.makeUintType(32);
4410 spvType = builder.makeBoolType();
4413 spvType = builder.makeIntType(32);
4416 spvType = builder.makeUintType(32);
4419 spvType = builder.makeFloatType(32);
4422 spvType = builder.makeFloatType(64);
4425 spvType = builder.makeFloatType(16);
4428 spvType = builder.makeIntType(8);
4431 spvType = builder.makeUintType(8);
4434 spvType = builder.makeIntType(16);
4437 spvType = builder.makeUintType(16);
4440 spvType = builder.makeIntType(64);
4443 spvType = builder.makeUintType(64);
4446 builder.addCapability(spv::CapabilityAtomicStorage);
4447 spvType = builder.makeUintType(32);
4463 builder.addExtension(spv::E_SPV_KHR_ray_query);
4464 builder.addCapability(spv::CapabilityRayQueryKHR);
4469 spvType = builder.makeAccelerationStructureType();
4475 builder.addExtension(spv::E_SPV_KHR_ray_query);
4476 builder.addCapability(spv::CapabilityRayQueryKHR);
4478 spvType = builder.makeRayQueryType();
4486 spv::Id forwardId = builder.makeForwardPointer(spv::StorageClassPhysicalStorageBufferEXT);
4492 builder.makePointerFromForwardPointer(spv::StorageClassPhysicalStorageBufferEXT,
4502 spvType = builder.makeSamplerType();
4505 spvType = builder.makeImageType(getSampledType(sampler), TranslateDimensionality(sampler),
4512 spvType = builder.makeSampledImageType(spvType);
4541 builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
4542 builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
4543 spvType = builder.makeHitObjectNVType();
4607 spvType = builder.makeGenericType(static_cast<spv::Op>(spirvInst.id), operands);
4617 spvType = builder.makeMatrixType(spvType, type.getMatrixCols(), type.getMatrixRows());
4621 spvType = builder.makeVectorType(spvType, type.getVectorSize());
4625 builder.addCapability(spv::CapabilityCooperativeMatrixNV);
4626 builder.addExtension(spv::E_SPV_NV_cooperative_matrix);
4629 builder.addCapability(spv::CapabilityFloat16);
4632 builder.addCapability(spv::CapabilityInt8);
4639 spvType = builder.makeCooperativeMatrixTypeNV(spvType, scope, rows, cols);
4643 builder.addCapability(spv::CapabilityCooperativeMatrixKHR);
4644 builder.addExtension(spv::E_SPV_KHR_cooperative_matrix);
4647 builder.addCapability(spv::CapabilityFloat16);
4649 builder.addCapability(spv::CapabilityInt8);
4655 spv::Id use = builder.makeUintConstant(type.getCoopMatKHRuse());
4657 spvType = builder.makeCooperativeMatrixTypeKHR(spvType, scope, rows, cols, use);
4680 spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), dim), stride);
4682 builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
4696 spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), 0), stride);
4699 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
4700 builder.addCapability(spv::CapabilityRuntimeDescriptorArrayEXT);
4702 spvType = builder.makeRuntimeArray(spvType);
4705 builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
4725 builder.addMemberDecoration(id, *member, static_cast<spv::Decoration>(decorate.first), literals);
4727 builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first), literals);
4730 builder.addMemberDecoration(id, *member, static_cast<spv::Decoration>(decorate.first));
4732 builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first));
4750 builder.addDecorationId(id, static_cast<spv::Decoration>(decorateId.first), operandIds);
4763 builder.addMemberDecoration(id, *member, static_cast<spv::Decoration>(decorateString.first), strings);
4765 builder.addDecoration(id, static_cast<spv::Decoration>(decorateString.first), strings);
4856 // Update the builder with the type's location so that we can create debug types for the structure members.
4857 // There doesn't exist a "clean" entry point for this information to be passed along to the builder so, for now,
4858 // it is stored in the builder and consumed during the construction of composite debug types.
4868 builder.debugTypeLocs[spvMember].name = glslangMember.type->getFieldName().c_str();
4869 builder.debugTypeLocs[spvMember].line = glslangMember.loc.line;
4870 builder.debugTypeLocs[spvMember].column = glslangMember.loc.column;
4876 spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str(), false);
4919 builder.addMemberName(spvType, member, glslangMember.getFieldName().c_str());
4920 builder.addMemberDecoration(spvType, member,
4922 builder.addMemberDecoration(spvType, member, TranslatePrecisionDecoration(glslangMember));
4929 builder.addMemberDecoration(spvType, member, TranslateInterpolationDecoration(memberQualifier));
4930 builder.addMemberDecoration(spvType, member, TranslateAuxiliaryStorageDecoration(memberQualifier));
4934 builder.addMemberDecoration(spvType, member, TranslateInvariantDecoration(memberQualifier));
4942 builder.addMemberDecoration(spvType, member, memory[i]);
4950 builder.addMemberDecoration(spvType, member, spv::DecorationLocation, memberQualifier.layoutLocation);
4954 builder.addMemberDecoration(spvType, member, spv::DecorationComponent,
4957 builder.addMemberDecoration(spvType, member, spv::DecorationOffset,
4964 builder.addMemberDecoration(spvType, member, spv::DecorationOffset, offset);
4969 builder.addMemberDecoration(spvType, member, spv::DecorationMatrixStride,
4975 builder.addMemberDecoration(spvType, member, spv::DecorationBuiltIn, (int)builtIn);
4978 builder.addMemberDecoration(spvType, member, TranslateNonUniformDecoration(glslangMember.getQualifier()));
4981 builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
4982 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
4989 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationViewportRelativeNV);
4990 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
4991 builder.addExtension(spv::E_SPV_NV_viewport_array2);
4994 builder.addMemberDecoration(spvType, member,
4997 builder.addCapability(spv::CapabilityShaderStereoViewNV);
4998 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
5002 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationPassthroughNV);
5003 builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
5004 builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
5013 builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix));
5017 builder.addDecoration(spvType, TranslateBlockDecoration(typeStorageQualifier, glslangIntermediate->usingStorageBuffer()));
5019 const auto hasRuntimeArray = !spvMembers.empty() && builder.getOpCode(spvMembers.back()) == spv::OpTypeRuntimeArray;
5021 builder.addDecoration(spvType, TranslateBlockDecoration(typeStorageQualifier, glslangIntermediate->usingStorageBuffer()));
5026 builder.addDecoration(spvType, spv::DecorationHitObjectShaderRecordBufferNV);
5038 builder.clearAccessChain();
5039 SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
5051 return builder.makeUintConstant(size);
5054 // Wrap the builder's accessChainLoad to:
5061 spv::Id nominalTypeId = builder.accessChainGetInferredType();
5063 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
5076 unsigned int alignment = builder.getAccessChain().alignment;
5079 spv::Id loadedId = builder.accessChainLoad(TranslatePrecisionDecoration(type),
5080 TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags),
5095 // Wrap the builder's accessChainStore to:
5098 // Implicitly uses the existing builder.accessChain as the storage target.
5103 spv::Id nominalTypeId = builder.accessChainGetInferredType();
5105 if (builder.isScalarType(nominalTypeId)) {
5107 spv::Id boolType = builder.makeBoolType();
5110 spv::Id one = builder.makeUintConstant(1);
5111 spv::Id zero = builder.makeUintConstant(0);
5112 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
5113 } else if (builder.getTypeId(rvalue) != boolType)
5114 rvalue = builder.createBinOp(spv::OpINotEqual, boolType, rvalue, builder.makeUintConstant(0));
5115 } else if (builder.isVectorType(nominalTypeId)) {
5117 int vecSize = builder.getNumTypeComponents(nominalTypeId);
5118 spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
5121 spv::Id one = makeSmearedConstant(builder.makeUintConstant(1), vecSize);
5122 spv::Id zero = makeSmearedConstant(builder.makeUintConstant(0), vecSize);
5123 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
5124 } else if (builder.getTypeId(rvalue) != bvecType)
5125 rvalue = builder.createBinOp(spv::OpINotEqual, bvecType, rvalue,
5126 makeSmearedConstant(builder.makeUintConstant(0), vecSize));
5130 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
5133 unsigned int alignment = builder.getAccessChain().alignment;
5136 builder.accessChainStore(rvalue, TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags),
5152 // Implicitly uses the existing builder.accessChain as the storage target.
5162 spv::Id rType = builder.getTypeId(rValue);
5163 spv::Id lValue = builder.accessChainGetLValue();
5164 spv::Id lType = builder.getContainedTypeId(builder.getTypeId(lValue));
5179 bool rBool = builder.containsType(builder.getTypeId(rValue), spv::OpTypeBool, 0);
5180 bool lBool = builder.containsType(lType, spv::OpTypeBool, 0);
5182 spv::Id logicalCopy = builder.createUnaryOp(spv::OpCopyLogical, lType, rValue);
5191 spv::Id elementRType = builder.getContainedTypeId(rType);
5194 spv::Id elementRValue = builder.createCompositeExtract(rValue, elementRType, index);
5197 builder.clearAccessChain();
5198 builder.setAccessChainLValue(lValue);
5199 builder.accessChainPush(builder.makeIntConstant(index), TranslateCoherent(type),
5214 spv::Id memberRType = builder.getContainedTypeId(rType, m);
5215 spv::Id memberRValue = builder.createCompositeExtract(rValue, memberRType, m);
5218 builder.clearAccessChain();
5219 builder.setAccessChainLValue(lValue);
5220 builder.accessChainPush(builder.makeIntConstant(m), TranslateCoherent(type),
5443 builder.setupDebugFunctionEntry(shaderEntry, glslangIntermediate->getEntryPointMangledName().c_str(),
5481 typeId = builder.makePointer(TranslateStorageClass(paramType), typeId);
5483 typeId = builder.makePointer(spv::StorageClassFunction, typeId);
5495 spv::Function* function = builder.makeFunctionEntry(
5499 builder.setupDebugFunctionEntry(function, glslFunction->getName().c_str(), glslFunction->getLoc().line,
5511 builder.addName(function->getParamId(p), parameters[p]->getAsSymbolNode()->getName().c_str());
5515 builder.addCapability(spv::CapabilityInt8);
5517 builder.addCapability(spv::CapabilityInt16);
5519 builder.addCapability(spv::CapabilityFloat16);
5527 builder.setBuildPoint(shaderEntry->getLastBlock());
5592 builder.setBuildPoint(functionBlock);
5593 builder.enterFunction(currentFunction);
5612 builder.clearAccessChain();
5719 spv::Id lvalue_id = builder.accessChainGetLValue();
5721 lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
5722 builder.addDecoration(lvalue_id, TranslateNonUniformDecoration(lvalueCoherentFlags));
5731 builder.clearAccessChain();
5741 builder.setLine(node->getLoc().line, node->getLoc().getFilename());
5754 if (builder.getSpvVersion() >= spv::Spv_1_4) {
5780 if (builder.isSampledImage(params.sampler) &&
5782 params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler);
5784 builder.addDecoration(params.sampler, spv::DecorationNonUniformEXT);
5794 return builder.createTextureQueryCall(spv::OpImageQuerySizeLod, params, isUnsignedResult);
5796 return builder.createTextureQueryCall(spv::OpImageQuerySize, params, isUnsignedResult);
5799 return builder.createTextureQueryCall(spv::OpImageQuerySamples, params, isUnsignedResult);
5802 return builder.createTextureQueryCall(spv::OpImageQueryLod, params, isUnsignedResult);
5804 return builder.createTextureQueryCall(spv::OpImageQueryLevels, params, isUnsignedResult);
5806 return builder.createUnaryOp(spv::OpImageSparseTexelsResident, builder.makeBoolType(), arguments[0]);
5842 spv::Id zero = builder.makeIntConstant(0);
5847 builder.makeCompositeConstant(builder.makeVectorType(builder.makeIntType(32), 2), comps) };
5861 spv::Id result = builder.createOp(spv::OpImageRead, resultType(), operands);
5862 builder.setPrecision(result, precision);
5871 spv::Id result = builder.createOp(spv::OpColorAttachmentReadEXT, resultType(), operands);
5872 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
5873 builder.setPrecision(result, precision);
5885 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5886 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5906 builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
5910 if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5911 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
5913 std::vector<spv::Id> result(1, builder.createOp(spv::OpImageRead, resultType(), operands));
5914 builder.setPrecision(result[0], precision);
5918 result[0] = builder.createConstructor(precision, result, convertGlslangToSpvType(node->getType()));
5937 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5938 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5958 builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
5962 builder.createNoResultOp(spv::OpImageWrite, operands);
5963 if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5964 builder.addCapability(spv::CapabilityStorageImageWriteWithoutFormat);
5968 builder.addCapability(spv::CapabilitySparseResidency);
5969 if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5970 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
5977 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5978 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5998 spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(
6006 spv::Id typeId1 = builder.getDerefTypeId(texelOut);
6007 spv::Id resultTypeId = builder.makeStructResultType(typeId0, typeId1);
6009 spv::Id resultId = builder.createOp(spv::OpImageSparseRead, resultTypeId, operands);
6012 builder.createStore(builder.createCompositeExtract(resultId, typeId1, 1), texelOut);
6013 return builder.createCompositeExtract(resultId, typeId0, 0);
6020 spv::IdImmediate sample = { true, sampler.isMultiSample() ? *(opIt++) : builder.makeUintConstant(0) };
6028 resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(*opIt));
6031 resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
6033 spv::Id pointer = builder.createOp(spv::OpImageTexelPointer, resultTypeId, operands);
6035 builder.addDecoration(pointer, spv::DecorationNonUniformEXT);
6060 spv::Id zero = builder.makeIntConstant(0);
6064 operands.push_back(builder.makeCompositeConstant(
6065 builder.makeVectorType(builder.makeIntType(32), 2), comps));
6077 builder.addExtension(spv::E_SPV_AMD_shader_fragment_mask);
6078 builder.addCapability(spv::CapabilityFragmentMaskAMD);
6079 return builder.createOp(fragMaskOp, resultType(), operands);
6118 builder.addExtension(spv::E_SPV_AMD_texture_gather_bias_lod);
6119 builder.addCapability(spv::CapabilityImageGatherBiasLodAMD);
6142 dRefComp = builder.getNumComponents(params.coords) - 1;
6144 params.Dref = builder.createCompositeExtract(params.coords,
6145 builder.getScalarTypeId(builder.getTypeId(params.coords)), indexes);
6198 params.component = builder.makeIntConstant(0);
6217 builder.addExtension(spv::E_SPV_NV_shader_image_footprint);
6218 builder.addCapability(spv::CapabilityImageFootprintNV);
6237 spv::Id resultStructType = builder.getContainedTypeId(builder.getTypeId(resultStruct));
6238 assert(builder.isStructType(resultStructType));
6250 members.push_back(builder.getContainedTypeId(resultStructType, i));
6252 spv::Id resType = builder.makeStructType(members, "ResType");
6255 spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj,
6260 builder.clearAccessChain();
6261 builder.setAccessChainLValue(resultStruct);
6267 builder.accessChainPush(builder.makeIntConstant(i), flags, 0);
6268 builder.accessChainStore(builder.createCompositeExtract(res, builder.getContainedTypeId(resType, i+1),
6271 return builder.createCompositeExtract(res, resultType(), 0);
6280 int projSourceComp = builder.getNumComponents(params.coords) - 1;
6290 spv::Id projComp = builder.createCompositeExtract(params.coords,
6291 builder.getScalarTypeId(builder.getTypeId(params.coords)), projSourceComp);
6292 params.coords = builder.createCompositeInsert(projComp, params.coords,
6293 builder.getTypeId(params.coords), projTargetComp);
6308 builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather,
6313 result[0] = builder.createConstructor(precision, result, convertGlslangToSpvType(node->getType()));
6343 builder.clearAccessChain();
6349 lValues.push_back(builder.getAccessChain());
6366 builder.setAccessChain(lValues[lValueCount]);
6367 arg = builder.accessChainGetLValue();
6371 arg = builder.createVariable(function->getParamPrecision(a), spv::StorageClassFunction,
6372 builder.getContainedTypeId(function->getParamType(a)), "param");
6375 builder.setAccessChain(lValues[lValueCount]);
6377 builder.clearAccessChain();
6378 builder.setAccessChainLValue(arg);
6384 if (function->getParamType(a) != builder.getTypeId(rValues[rValueCount]) ||
6387 spv::Id argCopy = builder.createVariable(function->getParamPrecision(a), spv::StorageClassFunction, function->getParamType(a), "arg");
6388 builder.clearAccessChain();
6389 builder.setAccessChainLValue(argCopy);
6391 arg = builder.createLoad(argCopy, function->getParamPrecision(a));
6400 spv::Id result = builder.createFunctionCall(function, spvArgs);
6401 builder.setPrecision(result, TranslatePrecisionDecoration(node->getType()));
6402 builder.addDecoration(result, TranslateNonUniformDecoration(node->getType().getQualifier()));
6411 spv::Id copy = builder.createLoad(spvArgs[a], spv::NoPrecision);
6412 builder.addDecoration(copy, TranslateNonUniformDecoration(argTypes[a]->getQualifier()));
6413 builder.setAccessChain(lValues[lValueCount]);
6460 if (isFloat && (builder.isVector(left) || builder.isVector(right))) {
6461 if (builder.isVector(right))
6463 assert(builder.isScalar(right));
6586 if (builder.isMatrix(left) || builder.isMatrix(right) ||
6587 builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right))
6592 builder.promoteScalar(decorations.precision, left, right);
6594 spv::Id result = builder.createBinOp(binOp, typeId, left, right);
6595 decorations.addNoContraction(builder, result);
6596 decorations.addNonUniform(builder, result);
6597 return builder.setPrecision(result, decorations.precision);
6606 && (builder.isVector(left) || builder.isMatrix(left) || builder.isAggregate(left))) {
6607 spv::Id result = builder.createCompositeCompare(decorations.precision, left, right, op == glslang::EOpEqual);
6608 decorations.addNonUniform(builder, result);
6668 spv::Id result = builder.createBinOp(binOp, typeId, left, right);
6669 decorations.addNoContraction(builder, result);
6670 decorations.addNonUniform(builder, result);
6671 return builder.setPrecision(result, decorations.precision);
6699 if (builder.isMatrix(left) && builder.isScalar(right)) {
6701 spv::Id resultType = builder.getTypeId(right);
6702 right = builder.createBinOp(spv::OpFDiv, resultType, builder.makeFpConstant(resultType, 1.0), right);
6708 if (builder.isMatrix(right) || builder.isCooperativeMatrix(right))
6710 assert(builder.isScalar(right));
6713 assert(builder.isVector(left));
6714 assert(builder.isMatrix(right));
6717 assert(builder.isMatrix(left));
6718 assert(builder.isVector(right));
6721 assert(builder.isMatrix(left));
6722 assert(builder.isMatrix(right));
6729 if (builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right))
6733 spv::Id result = builder.createBinOp(op, typeId, left, right);
6734 decorations.addNoContraction(builder, result);
6735 decorations.addNonUniform(builder, result);
6736 return builder.setPrecision(result, decorations.precision);
6754 bool leftMat = builder.isMatrix(left);
6755 bool rightMat = builder.isMatrix(right);
6756 unsigned int numCols = leftMat ? builder.getNumColumns(left) : builder.getNumColumns(right);
6757 int numRows = leftMat ? builder.getNumRows(left) : builder.getNumRows(right);
6758 spv::Id scalarType = builder.getScalarTypeId(typeId);
6759 spv::Id vecType = builder.makeVectorType(scalarType, numRows);
6762 if (builder.isScalar(left))
6763 smearVec = builder.smearScalar(decorations.precision, left, vecType);
6764 else if (builder.isScalar(right))
6765 smearVec = builder.smearScalar(decorations.precision, right, vecType);
6771 spv::Id leftVec = leftMat ? builder.createCompositeExtract( left, vecType, indexes) : smearVec;
6772 spv::Id rightVec = rightMat ? builder.createCompositeExtract(right, vecType, indexes) : smearVec;
6773 spv::Id result = builder.createBinOp(op, vecType, leftVec, rightVec);
6774 decorations.addNoContraction(builder, result);
6775 decorations.addNonUniform(builder, result);
6776 results.push_back(builder.setPrecision(result, decorations.precision));
6780 spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision);
6781 decorations.addNonUniform(builder, result);
6803 if (builder.isMatrixType(typeId))
7069 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
7099 builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
7100 builder.addExtension("SPV_INTEL_shader_integer_functions2");
7105 builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
7106 builder.addExtension("SPV_INTEL_shader_integer_functions2");
7292 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
7293 builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
7298 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
7299 builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
7312 id = builder.createBuiltinCall(typeId, extBuiltins >= 0 ? extBuiltins : stdBuiltins, libCall, args);
7314 id = builder.createUnaryOp(unaryOp, typeId, operand);
7317 decorations.addNoContraction(builder, id);
7318 decorations.addNonUniform(builder, id);
7319 return builder.setPrecision(id, decorations.precision);
7334 int numCols = builder.getNumColumns(operand);
7335 int numRows = builder.getNumRows(operand);
7336 spv::Id srcVecType = builder.makeVectorType(builder.getScalarTypeId(builder.getTypeId(operand)), numRows);
7337 spv::Id destVecType = builder.makeVectorType(builder.getScalarTypeId(typeId), numRows);
7344 spv::Id srcVec = builder.createCompositeExtract(operand, srcVecType, indexes);
7345 spv::Id destVec = builder.createUnaryOp(op, destVecType, srcVec);
7346 decorations.addNoContraction(builder, destVec);
7347 decorations.addNonUniform(builder, destVec);
7348 results.push_back(builder.setPrecision(destVec, decorations.precision));
7352 spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision);
7353 decorations.addNonUniform(builder, result);
7423 type = builder.makeIntType(width);
7427 type = builder.makeUintType(width);
7432 type = builder.makeVectorType(type, vectorSize);
7433 else if (builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixKHR ||
7434 builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixNV) {
7436 type = builder.makeCooperativeMatrixTypeWithSameShape(type, destType);
7439 return builder.createUnaryOp(convOp, type, operand);
7449 int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0;
7454 zero = builder.makeUintConstant(0);
7456 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7458 zero = builder.makeFloatConstant(0.0F);
7460 return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7463 zero = builder.makeFloatConstant(0.0F);
7464 one = builder.makeFloatConstant(1.0F);
7470 zero = builder.makeInt64Constant(0);
7471 one = builder.makeInt64Constant(1);
7473 zero = builder.makeIntConstant(0);
7474 one = builder.makeIntConstant(1);
7483 zero = builder.makeUint64Constant(0);
7484 one = builder.makeUint64Constant(1);
7486 zero = builder.makeUintConstant(0);
7487 one = builder.makeUintConstant(1);
7546 if (builder.isInSpecConstCodeGenMode()) {
7549 zero = builder.makeUint8Constant(0);
7551 zero = builder.makeUint16Constant(0);
7553 zero = builder.makeUint64Constant(0);
7555 zero = builder.makeUintConstant(0);
7560 return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
7583 zero = builder.makeUint8Constant(0);
7585 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7588 zero = builder.makeUint16Constant(0);
7590 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7593 zero = builder.makeUint64Constant(0);
7595 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7597 zero = builder.makeDoubleConstant(0.0);
7599 return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7601 zero = builder.makeFloat16Constant(0.0F);
7603 return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7606 zero = builder.makeDoubleConstant(0.0);
7607 one = builder.makeDoubleConstant(1.0);
7611 zero = builder.makeFloat16Constant(0.0F);
7612 one = builder.makeFloat16Constant(1.0F);
7615 zero = builder.makeInt8Constant(0);
7616 one = builder.makeInt8Constant(1);
7620 zero = builder.makeUint8Constant(0);
7621 one = builder.makeUint8Constant(1);
7625 zero = builder.makeInt16Constant(0);
7626 one = builder.makeInt16Constant(1);
7630 zero = builder.makeUint16Constant(0);
7631 one = builder.makeUint16Constant(1);
7641 if (builder.isMatrixType(destType))
7702 if (builder.isInSpecConstCodeGenMode()) {
7711 zero = builder.makeUint8Constant(0);
7719 zero = builder.makeUint16Constant(0);
7727 zero = builder.makeUintConstant(0);
7735 zero = builder.makeUint64Constant(0);
7744 return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
7771 result = builder.createTriOp(convOp, destType, operand, one, zero);
7773 result = builder.createUnaryOp(convOp, destType, operand);
7775 result = builder.setPrecision(result, decorations.precision);
7776 decorations.addNonUniform(builder, result);
7785 spv::Id vectorTypeId = builder.makeVectorType(builder.getTypeId(constant), vectorSize);
7789 return builder.makeCompositeConstant(vectorTypeId, components);
7806 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_add);
7808 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float16_add);
7809 builder.addCapability(spv::CapabilityAtomicFloat16AddEXT);
7811 builder.addCapability(spv::CapabilityAtomicFloat32AddEXT);
7813 builder.addCapability(spv::CapabilityAtomicFloat64AddEXT);
7826 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
7828 builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
7830 builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
7832 builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
7844 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
7846 builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
7848 builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
7850 builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
7903 builder.addCapability(spv::CapabilityInt64Atomics);
7915 scopeId = builder.makeUintConstant(spv::ScopeQueueFamilyKHR);
7917 scopeId = builder.makeUintConstant(spv::ScopeDevice);
7920 spv::Id semanticsId = builder.makeUintConstant(lvalueCoherentFlags.isVolatile() &&
7934 semanticsId = builder.makeUintConstant(
7935 builder.getConstantScalar(operands[4]) | builder.getConstantScalar(operands[5]));
7936 semanticsId2 = builder.makeUintConstant(
7937 builder.getConstantScalar(operands[6]) | builder.getConstantScalar(operands[7]));
7942 semanticsId = builder.makeUintConstant(
7943 builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]));
7950 semanticsId = builder.makeUintConstant
7951 (builder.getConstantScalar(operands[3]) | builder.getConstantScalar(operands[4]));
7956 unsigned semanticsImmediate = builder.getConstantScalar(semanticsId) | builder.getConstantScalar(semanticsId2);
7961 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
7964 if (builder.getConstantScalar(scopeId) == spv::ScopeQueueFamily) {
7965 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
7968 if (glslangIntermediate->usingVulkanMemoryModel() && builder.getConstantScalar(scopeId) == spv::ScopeDevice) {
7969 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
7985 builder.createNoResultOp(opCode, spvAtomicOperands);
7988 spv::Id resultId = builder.createOp(opCode, typeId, spvAtomicOperands);
7993 resultId = builder.createBinOp(spv::OpISub, typeId, resultId, builder.makeIntConstant(1));
8012 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
8013 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
8017 builder.addExtension(spv::E_SPV_KHR_subgroup_vote);
8018 builder.addCapability(spv::CapabilitySubgroupVoteKHR);
8020 builder.addCapability(spv::CapabilityGroups);
8030 builder.addExtension(spv::E_SPV_AMD_shader_ballot);
8060 spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8085 if (builder.isVectorType(typeId))
8090 if (builder.isVectorType(typeId))
8101 spv::Id uintType = builder.makeUintType(32);
8102 spv::Id uvec4Type = builder.makeVectorType(uintType, 4);
8103 spv::Id result = builder.createOp(spv::OpSubgroupBallotKHR, uvec4Type, spvGroupOperands);
8106 components.push_back(builder.createCompositeExtract(result, uintType, 0));
8107 components.push_back(builder.createCompositeExtract(result, uintType, 1));
8109 spv::Id uvec2Type = builder.makeVectorType(uintType, 2);
8110 return builder.createUnaryOp(spv::OpBitcast, typeId,
8111 builder.createCompositeConstruct(uvec2Type, components));
8152 if (builder.isVectorType(typeId))
8196 if (builder.isVectorType(typeId))
8206 return builder.createOp(opCode, typeId, spvGroupOperands);
8231 int numComponents = builder.getNumComponents(operands[0]);
8232 spv::Id scalarType = builder.getScalarTypeId(builder.getTypeId(operands[0]));
8239 spv::IdImmediate scalar = { true, builder.createCompositeExtract(operands[0], scalarType, indexes) };
8248 spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8254 spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8261 results.push_back(builder.createOp(op, scalarType, spvGroupOperands));
8265 return builder.createCompositeConstruct(typeId, results);
8275 builder.addCapability(spv::CapabilityGroupNonUniform);
8280 builder.addCapability(spv::CapabilityGroupNonUniform);
8281 builder.addCapability(spv::CapabilityGroupNonUniformVote);
8293 builder.addCapability(spv::CapabilityGroupNonUniform);
8294 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
8298 builder.addCapability(spv::CapabilityGroupNonUniform);
8299 builder.addCapability(spv::CapabilityGroupNonUniformShuffle);
8303 builder.addCapability(spv::CapabilityGroupNonUniform);
8304 builder.addCapability(spv::CapabilityGroupNonUniformShuffleRelative);
8327 builder.addCapability(spv::CapabilityGroupNonUniform);
8328 builder.addCapability(spv::CapabilityGroupNonUniformArithmetic);
8337 builder.addCapability(spv::CapabilityGroupNonUniform);
8338 builder.addCapability(spv::CapabilityGroupNonUniformClustered);
8344 builder.addCapability(spv::CapabilityGroupNonUniform);
8345 builder.addCapability(spv::CapabilityGroupNonUniformQuad);
8368 builder.addExtension(spv::E_SPV_NV_shader_subgroup_partitioned);
8369 builder.addCapability(spv::CapabilityGroupNonUniformPartitionedNV);
8580 spv::IdImmediate executionScope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8599 case glslang::EOpSubgroupQuadSwapHorizontal: directionId = builder.makeUintConstant(0); break;
8600 case glslang::EOpSubgroupQuadSwapVertical: directionId = builder.makeUintConstant(1); break;
8601 case glslang::EOpSubgroupQuadSwapDiagonal: directionId = builder.makeUintConstant(2); break;
8608 return builder.createOp(opCode, typeId, spvGroupOperands);
8623 typeId0 = builder.getTypeId(operands[0]);
8626 typeId1 = builder.getTypeId(operands[1]);
8637 builder.promoteScalar(precision, operands.front(), operands.back());
8649 builder.promoteScalar(precision, operands.front(), operands.back());
8668 builder.promoteScalar(precision, operands.front(), operands[1]);
8669 builder.promoteScalar(precision, operands.front(), operands[2]);
8672 if (! builder.isBoolType(builder.getScalarTypeId(builder.getTypeId(operands.back())))) {
8679 builder.promoteScalar(precision, operands.front(), operands.back());
8683 builder.promoteScalar(precision, operands.front(), operands.back());
8687 builder.promoteScalar(precision, operands[0], operands[2]);
8688 builder.promoteScalar(precision, operands[1], operands[2]);
8711 unsigned int executionScope = builder.getConstantScalar(operands[0]);
8712 unsigned int memoryScope = builder.getConstantScalar(operands[1]);
8713 unsigned int semantics = builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]);
8714 builder.createControlBarrier((spv::Scope)executionScope, (spv::Scope)memoryScope,
8720 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8724 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
8734 unsigned int memoryScope = builder.getConstantScalar(operands[0]);
8735 unsigned int semantics = builder.getConstantScalar(operands[1]) | builder.getConstantScalar(operands[2]);
8736 builder.createMemoryBarrier((spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics);
8741 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8744 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
8752 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8757 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8762 typeId = builder.makeStructResultType(typeId0, typeId0);
8767 typeId = builder.makeStructResultType(typeId0, typeId0);
8772 typeId = builder.makeStructResultType(typeId0, typeId0);
8777 typeId = builder.makeStructResultType(typeId0, typeId0);
8796 assert(builder.isPointerType(typeId1));
8797 typeId1 = builder.getContainedTypeId(typeId1);
8798 int width = builder.getScalarTypeWidth(typeId1);
8801 builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
8802 if (builder.getNumComponents(operands[0]) == 1)
8803 frexpIntType = builder.makeIntegerType(width, true);
8805 frexpIntType = builder.makeVectorType(builder.makeIntegerType(width, true),
8806 builder.getNumComponents(operands[0]));
8807 typeId = builder.makeStructResultType(typeId0, frexpIntType);
8904 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8910 typeId = builder.makeBoolType();
8914 builder.createNoResultOp(spv::OpTraceNV, operands);
8917 builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
8918 builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
8919 builder.createNoResultOp(spv::OpTraceRayMotionNV, operands);
8922 builder.createNoResultOp(spv::OpTraceRayKHR, operands);
8925 builder.createNoResultOp(spv::OpExecuteCallableNV, operands);
8928 builder.createNoResultOp(spv::OpExecuteCallableKHR, operands);
8932 builder.createNoResultOp(spv::OpRayQueryInitializeKHR, operands);
8935 builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operands);
8938 builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR, operands);
8941 builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operands);
8944 typeId = builder.makeBoolType();
8948 typeId = builder.makeUintType(32);
8952 typeId = builder.makeFloatType(32);
8956 typeId = builder.makeIntType(32);
8960 typeId = builder.makeFloatType(32);
8964 typeId = builder.makeIntType(32);
8968 typeId = builder.makeIntType(32);
8972 typeId = builder.makeUintType(32);
8976 typeId = builder.makeIntType(32);
8980 typeId = builder.makeIntType(32);
8984 typeId = builder.makeVectorType(builder.makeFloatType(32), 2);
8988 typeId = builder.makeBoolType();
8992 typeId = builder.makeBoolType();
8996 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9000 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9004 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9008 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9012 typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
9016 typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
9020 builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
9026 builder.makeStatementTerminator(spv::OpEmitMeshTasksEXT, operands, "post-OpEmitMeshTasksEXT");
9029 builder.createNoResultOp(spv::OpSetMeshOutputsEXT, operands);
9035 builder.createNoResultOp(spv::OpHitObjectTraceRayNV, operands);
9038 builder.createNoResultOp(spv::OpHitObjectTraceRayMotionNV, operands);
9041 builder.createNoResultOp(spv::OpHitObjectRecordHitNV, operands);
9044 builder.createNoResultOp(spv::OpHitObjectRecordHitMotionNV, operands);
9047 builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexNV, operands);
9050 builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexMotionNV, operands);
9053 builder.createNoResultOp(spv::OpHitObjectRecordMissNV, operands);
9056 builder.createNoResultOp(spv::OpHitObjectRecordMissMotionNV, operands);
9059 builder.createNoResultOp(spv::OpHitObjectExecuteShaderNV, operands);
9062 typeId = builder.makeBoolType();
9066 typeId = builder.makeBoolType();
9070 typeId = builder.makeBoolType();
9074 typeId = builder.makeFloatType(32);
9078 typeId = builder.makeFloatType(32);
9082 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9086 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9090 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9094 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9098 typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
9102 typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
9106 typeId = builder.makeIntegerType(32, 1);
9110 typeId = builder.makeIntegerType(32, 1);
9114 typeId = builder.makeIntegerType(32, 1);
9118 typeId = builder.makeIntegerType(32, 1);
9122 typeId = builder.makeIntegerType(32, 0);
9126 typeId = builder.makeFloatType(32);
9130 typeId = builder.makeIntegerType(32, 0);
9134 builder.createNoResultOp(spv::OpHitObjectGetAttributesNV, operands);
9137 typeId = builder.makeVectorType(builder.makeUintType(32), 2);
9142 builder.createNoResultOp(spv::OpReorderThreadWithHintNV, operands);
9144 builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operands);
9151 typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
9156 typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
9160 typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
9166 typeId = builder.makeVectorType(builder.makeFloatType(32), 4);
9173 typeId = builder.makeVectorType(builder.makeFloatType(32), 2);
9178 typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
9192 id = builder.createBuiltinCall(typeId, extBuiltins >= 0 ? extBuiltins : stdBuiltins, libCall, callArguments);
9196 const int componentCount = builder.getNumComponents(operands[0]);
9197 spv::Id mulOp = builder.createBinOp(spv::OpIMul, builder.getTypeId(operands[0]), operands[0], operands[1]);
9198 builder.setPrecision(mulOp, precision);
9199 id = builder.createCompositeExtract(mulOp, typeId, 0);
9201 builder.setPrecision(id, precision);
9202 id = builder.createBinOp(spv::OpIAdd, typeId, id, builder.createCompositeExtract(mulOp, typeId, i));
9215 id = builder.createBinOp(opCode, typeId, operands[0], operands[1]);
9220 id = builder.createOp(opCode, typeId, operands);
9229 builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]);
9230 id = builder.createCompositeExtract(id, typeId0, 0);
9234 builder.createStore(builder.createCompositeExtract(id, typeId0, 0), operands[3]);
9235 builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]);
9240 if (builder.isFloatType(builder.getScalarTypeId(typeId1))) {
9242 spv::Id member1 = builder.createCompositeExtract(id, frexpIntType, 1);
9243 member1 = builder.createUnaryOp(spv::OpConvertSToF, typeId1, member1);
9244 builder.createStore(member1, operands[1]);
9247 builder.createStore(builder.createCompositeExtract(id, frexpIntType, 1), operands[1]);
9248 id = builder.createCompositeExtract(id, typeId0, 0);
9255 return builder.setPrecision(id, precision);
9269 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
9272 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
9274 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, spv::MemorySemanticsMaskNone);
9277 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
9283 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAllMemory |
9287 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsUniformMemoryMask |
9291 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsWorkgroupMemoryMask |
9295 builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsAllMemory |
9299 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAtomicCounterMemoryMask |
9303 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsImageMemoryMask |
9307 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice,
9312 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
9317 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
9322 builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask |
9326 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
9331 builder.createControlBarrier(spv::ScopeSubgroup, spv::ScopeSubgroup, spv::MemorySemanticsAllMemory |
9335 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAllMemory |
9339 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsUniformMemoryMask |
9343 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask |
9347 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsWorkgroupMemoryMask |
9352 builder.createNoResultOp(spv::OpEmitVertex);
9355 builder.createNoResultOp(spv::OpEndPrimitive);
9365 spv::Id id = builder.createBuiltinCall(typeId, getExtBuiltins(spv::E_SPV_AMD_gcn_shader), spv::TimeAMD, args);
9366 return builder.setPrecision(id, precision);
9369 builder.createNoResultOp(spv::OpIgnoreIntersectionNV);
9372 builder.createNoResultOp(spv::OpTerminateRayNV);
9375 builder.createNoResultOp(spv::OpRayQueryInitializeKHR);
9378 builder.createNoResultOp(spv::OpRayQueryTerminateKHR);
9381 builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR);
9384 builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR);
9387 builder.createNoResultOp(spv::OpBeginInvocationInterlockEXT);
9390 builder.createNoResultOp(spv::OpEndInvocationInterlockEXT);
9396 builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
9397 builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT);
9398 return builder.createOp(spv::OpIsHelperInvocationEXT, typeId, args);
9403 args.push_back(builder.makeUintConstant(spv::ScopeSubgroup));
9404 builder.addExtension(spv::E_SPV_KHR_shader_clock);
9405 builder.addCapability(spv::CapabilityShaderClockKHR);
9406 return builder.createOp(spv::OpReadClockKHR, typeId, args);
9411 args.push_back(builder.makeUintConstant(spv::ScopeDevice));
9412 builder.addExtension(spv::E_SPV_KHR_shader_clock);
9413 builder.addCapability(spv::CapabilityShaderClockKHR);
9414 return builder.createOp(spv::OpReadClockKHR, typeId, args);
9419 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
9427 builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
9433 builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
9437 spv::Id result = builder.createOp(spv_op, typeId, args);
9438 return builder.setPrecision(result, precision);
9492 builder.addDecoration(id, TranslatePrecisionDecoration(symbol->getType()));
9493 builder.addDecoration(id, TranslateInterpolationDecoration(symbol->getType().getQualifier()));
9494 builder.addDecoration(id, TranslateAuxiliaryStorageDecoration(symbol->getType().getQualifier()));
9497 builder.addDecoration(id, spv::DecorationComponent, symbol->getQualifier().layoutComponent);
9499 builder.addDecoration(id, spv::DecorationIndex, symbol->getQualifier().layoutIndex);
9501 builder.addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId);
9504 builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset);
9511 && (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
9512 builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
9513 builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
9514 builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR ||
9515 builder.getStorageClass(id) == spv::StorageClassHitObjectAttributeNV))) {
9519 builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
9523 builder.addDecoration(id, TranslateInvariantDecoration(symbol->getType().getQualifier()));
9525 builder.addCapability(spv::CapabilityGeometryStreams);
9526 builder.addDecoration(id, spv::DecorationStream, symbol->getQualifier().layoutStream);
9529 builder.addDecoration(id, spv::DecorationDescriptorSet, symbol->getQualifier().layoutSet);
9532 builder.addDecoration(id, spv::DecorationDescriptorSet, 0);
9535 builder.addDecoration(id, spv::DecorationBinding, symbol->getQualifier().layoutBinding);
9538 builder.addDecoration(id, spv::DecorationBinding, 0);
9541 builder.addDecoration(id, spv::DecorationInputAttachmentIndex, symbol->getQualifier().layoutAttachment);
9543 builder.addCapability(spv::CapabilityTransformFeedback);
9545 builder.addDecoration(id, spv::DecorationXfbBuffer, symbol->getQualifier().layoutXfbBuffer);
9548 builder.addDecoration(id, spv::DecorationXfbStride, stride);
9551 builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutXfbOffset);
9559 builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
9566 builder.addDecoration(id, spv::DecorationVolatile);
9575 builder.addDecoration(id, memory[i]);
9585 builder.addDecoration(id, decoration);
9587 builder.addCapability(spv::CapabilitySampleMaskOverrideCoverageNV);
9588 builder.addExtension(spv::E_SPV_NV_sample_mask_override_coverage);
9594 builder.addDecoration(id, (spv::Decoration)spv::DecorationViewportRelativeNV);
9595 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
9596 builder.addExtension(spv::E_SPV_NV_viewport_array2);
9599 builder.addDecoration(id, (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV,
9601 builder.addCapability(spv::CapabilityShaderStereoViewNV);
9602 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
9607 builder.addDecoration(id, spv::DecorationPassthroughNV);
9608 builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
9609 builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
9612 builder.addDecoration(id, spv::DecorationPerVertexNV);
9613 builder.addCapability(spv::CapabilityFragmentBarycentricNV);
9614 builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
9618 builder.addDecoration(id, spv::DecorationPerVertexKHR);
9619 builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
9620 builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
9624 builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
9625 builder.addDecoration(id, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
9630 builder.addDecoration(id, symbol->getType().getQualifier().restrict ?
9653 builder.addCapability(spv::CapabilityMeshShadingEXT);
9654 builder.addExtension(spv::E_SPV_EXT_mesh_shader);
9656 builder.addCapability(spv::CapabilityMeshShadingNV);
9657 builder.addExtension(spv::E_SPV_NV_mesh_shader);
9660 builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV);
9663 builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerViewNV);
9665 builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerTaskNV);
9672 builder.addCapability(spv::CapabilityMeshShadingEXT);
9673 builder.addExtension(spv::E_SPV_EXT_mesh_shader);
9675 builder.addCapability(spv::CapabilityMeshShadingNV);
9676 builder.addExtension(spv::E_SPV_NV_mesh_shader);
9679 builder.addDecoration(id, spv::DecorationPerPrimitiveNV);
9682 builder.addDecoration(id, spv::DecorationPerViewNV);
9684 builder.addDecoration(id, spv::DecorationPerTaskNV);
9690 spv::Op opc = builder.getOpCode(id);
9692 id = builder.getIdOperand(id, 0);
9693 opc = builder.getOpCode(id);
9697 spv::Id texid = builder.getIdOperand(id, 0);
9698 builder.addDecoration(texid, decor);
9730 builder.addCapability(spv::CapabilityInt8);
9732 builder.addCapability(spv::CapabilityFloat16);
9734 builder.addCapability(spv::CapabilityInt16);
9736 builder.addCapability(spv::CapabilityInt64);
9738 builder.addCapability(spv::CapabilityFloat64);
9746 dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
9748 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
9752 return builder.makeCompositeConstant(builder.makeVectorType(builder.makeUintType(32), 3), dimConstId, true);
9762 // will set the builder into spec constant op instruction generating mode.
9772 builder.addName(result, sn->getName().c_str());
9817 spvConsts.push_back(builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst()));
9820 spvConsts.push_back(builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst()));
9823 spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
9826 spvConsts.push_back(builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst()));
9829 builder.addCapability(spv::CapabilityInt8);
9830 spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const()));
9833 builder.addCapability(spv::CapabilityInt8);
9834 spvConsts.push_back(builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const()));
9837 builder.addCapability(spv::CapabilityInt16);
9838 spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const()));
9841 builder.addCapability(spv::CapabilityInt16);
9842 spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const()));
9845 spvConsts.push_back(builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const()));
9848 spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const()));
9851 spvConsts.push_back(builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst()));
9854 builder.addCapability(spv::CapabilityFloat16);
9855 spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
9869 scalar = builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst(), specConstant);
9872 scalar = builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst(), specConstant);
9875 scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
9878 scalar = builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst(), specConstant);
9881 builder.addCapability(spv::CapabilityInt8);
9882 scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant);
9885 builder.addCapability(spv::CapabilityInt8);
9886 scalar = builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const(), specConstant);
9889 builder.addCapability(spv::CapabilityInt16);
9890 scalar = builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const(), specConstant);
9893 builder.addCapability(spv::CapabilityInt16);
9894 scalar = builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const(), specConstant);
9897 scalar = builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const(), specConstant);
9900 scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
9903 scalar = builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst(), specConstant);
9906 builder.addCapability(spv::CapabilityFloat16);
9907 scalar = builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
9910 scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
9911 scalar = builder.createUnaryOp(spv::OpBitcast, typeId, scalar);
9914 scalar = builder.getStringId(consts[nextConst].getSConst()->c_str());
9924 return builder.makeCompositeConstant(typeId, spvConsts);
10019 spv::Id boolTypeId = builder.makeBoolType();
10022 builder.clearAccessChain();
10030 phiOperands.push_back(builder.getBuildPoint()->getId());
10037 // to 'builder' to have an "else" without an "then"
10039 leftId = builder.createUnaryOp(spv::OpLogicalNot, boolTypeId, leftId);
10042 spv::Builder::If ifBuilder(leftId, spv::SelectionControlMaskNone, builder);
10045 builder.clearAccessChain();
10051 phiOperands.push_back(builder.getBuildPoint()->getId());
10057 return builder.createOp(spv::OpPhi, boolTypeId, phiOperands);
10067 builder.addExtension(name);
10068 spv::Id extBuiltins = builder.import(name);