diff --git a/build.zig b/build.zig index 6a707621fc3a..84317cb11c40 100644 --- a/build.zig +++ b/build.zig @@ -66,6 +66,23 @@ pub fn build(b: *std.Build) !void { b.getInstallStep().dependOn(&install_std_docs.step); } + const update_cpu_features = b.addExecutable(.{ + .name = "update-cpu-features", + .root_module = b.createModule(.{ + .root_source_file = b.path("tools/update_cpu_features.zig"), + .target = b.graph.host, + .imports = &.{.{ + .name = "spirv_spec", + .module = b.createModule(.{ + .root_source_file = b.path("src/codegen/spirv/spec.zig"), + .target = b.graph.host, + }), + }}, + }), + }); + const run_update_cpu_features = b.addRunArtifact(update_cpu_features); + if (b.args) |args| run_update_cpu_features.addArgs(args); + if (flat) { b.installFile("LICENSE", "LICENSE"); b.installFile("README.md", "README.md"); @@ -81,6 +98,9 @@ pub fn build(b: *std.Build) !void { docs_step.dependOn(langref_step); docs_step.dependOn(std_docs_step); + const update_cpu_features_step = b.step("update-cpu-features", "Update CPU Features"); + update_cpu_features_step.dependOn(&run_update_cpu_features.step); + const no_matrix = b.option(bool, "no-matrix", "Limit test matrix to exactly one target configuration") orelse false; const skip_debug = b.option(bool, "skip-debug", "Main test suite skips debug builds") orelse false; const skip_release = b.option(bool, "skip-release", "Main test suite skips release builds") orelse no_matrix; diff --git a/lib/std/Target.zig b/lib/std/Target.zig index cbbbc863981d..79915db6dfff 100644 --- a/lib/std/Target.zig +++ b/lib/std/Target.zig @@ -1183,7 +1183,7 @@ pub const Cpu = struct { pub const Set = struct { ints: [usize_count]usize, - pub const needed_bit_count = 317; + pub const needed_bit_count = 421; pub const byte_count = (needed_bit_count + 7) / 8; pub const usize_count = (byte_count + (@sizeOf(usize) - 1)) / @sizeOf(usize); pub const Index = std.math.Log2Int(std.meta.Int(.unsigned, usize_count * @bitSizeOf(usize))); @@ -1917,6 +1917,8 @@ pub const Cpu = struct { .spirv_kernel, .spirv_fragment, .spirv_vertex, + .spirv_task, + .spirv_mesh, => &.{ .spirv32, .spirv64 }, }; } @@ -3265,6 +3267,12 @@ pub fn cTypeBitSize(target: *const Target, c_type: CType) u16 { .longdouble => return 128, }, + // OpenGL has no well defined C ABI, we do this to prevent panic when using floating point types. + .opengl => switch (c_type) { + .char, .short, .ushort, .int, .uint, .float, .long, .ulong, .longlong, .ulonglong => return 32, + .double, .longdouble => return 64, + }, + .opencl, .vulkan => switch (c_type) { .char => return 8, .short, .ushort => return 16, @@ -3300,9 +3308,8 @@ pub fn cTypeBitSize(target: *const Target, c_type: CType) u16 { }, .ps3, - .contiki, .managarm, - .opengl, + .contiki, => @panic("specify the C integer and float type sizes for this OS"), } } diff --git a/lib/std/Target/spirv.zig b/lib/std/Target/spirv.zig index 28fda54e9d66..d36ad6921813 100644 --- a/lib/std/Target/spirv.zig +++ b/lib/std/Target/spirv.zig @@ -5,12 +5,409 @@ const CpuFeature = std.Target.Cpu.Feature; const CpuModel = std.Target.Cpu.Model; pub const Feature = enum { - arbitrary_precision_integers, + addresses, + arbitrary_precision_fixed_point_intel, + arbitrary_precision_floating_point_intel, + arbitrary_precision_integers_intel, + arithmetic_fence_ext, + asm_intel, + atomic_float16add_ext, + atomic_float16min_max_ext, + atomic_float16vector_nv, + atomic_float32add_ext, + atomic_float32min_max_ext, + atomic_float64add_ext, + atomic_float64min_max_ext, + atomic_storage, + atomic_storage_ops, + b_float16conversion_intel, + b_float16cooperative_matrix_khr, + b_float16dot_product_khr, + b_float16type_khr, + bindless_images_intel, + bindless_texture_nv, + bit_instructions, + blocking_pipes_intel, + cache_controls_intel, + clip_distance, + compute_derivative_group_linear_khr, + compute_derivative_group_quads_khr, + cooperative_matrix_block_loads_nv, + cooperative_matrix_conversion_qcom, + cooperative_matrix_conversions_nv, + cooperative_matrix_khr, + cooperative_matrix_layouts_arm, + cooperative_matrix_nv, + cooperative_matrix_per_element_operations_nv, + cooperative_matrix_reductions_nv, + cooperative_matrix_tensor_addressing_nv, + cooperative_vector_nv, + cooperative_vector_training_nv, + core_builtins_arm, + cull_distance, + debug_info_module_intel, + demote_to_helper_invocation, + denorm_flush_to_zero, + denorm_preserve, + derivative_control, + device_enqueue, + device_group, + displacement_micromap_nv, + dot_product, + dot_product_input4x8bit, + dot_product_input4x8bit_packed, + dot_product_input_all, + draw_parameters, + expect_assume_khr, float16, + float16buffer, + float16image_amd, float64, + float8cooperative_matrix_ext, + float8ext, + float_controls2, + floating_point_mode_intel, + fp_fast_math_mode_intel, + fp_max_error_intel, + fpga_argument_interfaces_intel, + fpga_buffer_location_intel, + fpga_cluster_attributes_intel, + fpga_cluster_attributes_v2intel, + fpga_invocation_pipelining_attributes_intel, + fpga_kernel_attributes_intel, + fpga_kernel_attributesv2intel, + fpga_latency_control_intel, + fpga_loop_controls_intel, + fpga_memory_accesses_intel, + fpga_memory_attributes_intel, + fpga_reg_intel, + fpgadsp_control_intel, + fragment_barycentric_khr, + fragment_density_ext, + fragment_fully_covered_ext, + fragment_mask_amd, + fragment_shader_pixel_interlock_ext, + fragment_shader_sample_interlock_ext, + fragment_shader_shading_rate_interlock_ext, + fragment_shading_rate_khr, + function_float_control_intel, + function_pointers_intel, + function_variants_intel, generic_pointer, + geometry, + geometry_point_size, + geometry_shader_passthrough_nv, + geometry_streams, + global_variable_fpga_decorations_intel, + global_variable_host_access_intel, + graph_arm, + group_non_uniform, + group_non_uniform_arithmetic, + group_non_uniform_ballot, + group_non_uniform_clustered, + group_non_uniform_partitioned_nv, + group_non_uniform_quad, + group_non_uniform_rotate_khr, + group_non_uniform_shuffle, + group_non_uniform_shuffle_relative, + group_non_uniform_vote, + group_uniform_arithmetic_khr, + groups, + image1d, + image_basic, + image_buffer, + image_cube_array, + image_footprint_nv, + image_gather_bias_lod_amd, + image_gather_extended, + image_mipmap, + image_ms_array, + image_query, + image_read_write, + image_read_write_lod_amd, + image_rect, + indirect_references_intel, + input_attachment, + input_attachment_array_dynamic_indexing, + input_attachment_array_non_uniform_indexing, + int16, + int4cooperative_matrix_intel, + int4type_intel, int64, + int64atomics, + int64image_ext, + int8, + integer_functions2intel, + interpolation_function, + io_pipes_intel, + kernel, + kernel_attributes_intel, + linkage, + literal_sampler, + long_composites_intel, + loop_fuse_intel, + masked_gather_scatter_intel, + matrix, + memory_access_aliasing_intel, + mesh_shading_ext, + mesh_shading_nv, + min_lod, + multi_view, + multi_viewport, + named_barrier, + opt_none_ext, + per_view_attributes_nv, + physical_storage_buffer_addresses, + pipe_storage, + pipes, + quad_control_khr, + raw_access_chains_nv, + ray_cull_mask_khr, + ray_query_khr, + ray_query_position_fetch_khr, + ray_query_provisional_khr, + ray_tracing_cluster_acceleration_structure_nv, + ray_tracing_displacement_micromap_nv, + ray_tracing_khr, + ray_tracing_linear_swept_spheres_geometry_nv, + ray_tracing_motion_blur_nv, + ray_tracing_nv, + ray_tracing_opacity_micromap_ext, + ray_tracing_position_fetch_khr, + ray_tracing_provisional_khr, + ray_tracing_spheres_geometry_nv, + ray_traversal_primitive_culling_khr, + register_limits_intel, + replicated_composites_ext, + round_to_infinity_intel, + rounding_mode_rte, + rounding_mode_rtz, + runtime_aligned_attribute_intel, + runtime_descriptor_array, + sample_mask_override_coverage_nv, + sample_mask_post_depth_coverage, + sample_rate_shading, + sampled1d, + sampled_buffer, + sampled_cube_array, + sampled_image_array_dynamic_indexing, + sampled_image_array_non_uniform_indexing, + sampled_rect, + shader, + shader_clock_khr, + shader_enqueue_amdx, + shader_invocation_reorder_nv, + shader_layer, + shader_non_uniform, + shader_sm_builtins_nv, + shader_stereo_view_nv, + shader_viewport_index, + shader_viewport_index_layer_ext, + shader_viewport_mask_nv, + signed_zero_inf_nan_preserve, + sparse_residency, + spec_conditional_intel, + split_barrier_intel, + SPV_AMD_gpu_shader_half_float_fetch, + SPV_AMD_shader_ballot, + SPV_AMD_shader_fragment_mask, + SPV_AMD_shader_image_load_store_lod, + SPV_AMD_texture_gather_bias_lod, + SPV_AMDX_shader_enqueue, + SPV_ARM_cooperative_matrix_layouts, + SPV_ARM_core_builtins, + SPV_ARM_graph, + SPV_ARM_tensors, + SPV_EXT_arithmetic_fence, + SPV_EXT_demote_to_helper_invocation, + SPV_EXT_descriptor_indexing, + SPV_EXT_float8, + SPV_EXT_fragment_fully_covered, + SPV_EXT_fragment_invocation_density, + SPV_EXT_fragment_shader_interlock, + SPV_EXT_mesh_shader, + SPV_EXT_opacity_micromap, + SPV_EXT_optnone, + SPV_EXT_physical_storage_buffer, + SPV_EXT_replicated_composites, + SPV_EXT_shader_atomic_float16_add, + SPV_EXT_shader_atomic_float_add, + SPV_EXT_shader_atomic_float_min_max, + SPV_EXT_shader_image_int64, + SPV_EXT_shader_stencil_export, + SPV_EXT_shader_tile_image, + SPV_EXT_shader_viewport_index_layer, + SPV_INTEL_2d_block_io, + SPV_INTEL_arbitrary_precision_fixed_point, + SPV_INTEL_arbitrary_precision_floating_point, + SPV_INTEL_arbitrary_precision_integers, + SPV_INTEL_bfloat16_conversion, + SPV_INTEL_bindless_images, + SPV_INTEL_blocking_pipes, + SPV_INTEL_cache_controls, + SPV_INTEL_debug_module, + SPV_INTEL_device_side_avc_motion_estimation, + SPV_INTEL_float_controls2, + SPV_INTEL_fp_fast_math_mode, + SPV_INTEL_fp_max_error, + SPV_INTEL_fpga_argument_interfaces, + SPV_INTEL_fpga_buffer_location, + SPV_INTEL_fpga_cluster_attributes, + SPV_INTEL_fpga_dsp_control, + SPV_INTEL_fpga_invocation_pipelining_attributes, + SPV_INTEL_fpga_latency_control, + SPV_INTEL_fpga_loop_controls, + SPV_INTEL_fpga_memory_accesses, + SPV_INTEL_fpga_memory_attributes, + SPV_INTEL_fpga_reg, + SPV_INTEL_function_pointers, + SPV_INTEL_function_variants, + SPV_INTEL_global_variable_fpga_decorations, + SPV_INTEL_global_variable_host_access, + SPV_INTEL_inline_assembly, + SPV_INTEL_int4, + SPV_INTEL_io_pipes, + SPV_INTEL_kernel_attributes, + SPV_INTEL_long_composites, + SPV_INTEL_loop_fuse, + SPV_INTEL_masked_gather_scatter, + SPV_INTEL_maximum_registers, + SPV_INTEL_media_block_io, + SPV_INTEL_memory_access_aliasing, + SPV_INTEL_optnone, + SPV_INTEL_runtime_aligned, + SPV_INTEL_shader_integer_functions2, + SPV_INTEL_split_barrier, + SPV_INTEL_subgroup_buffer_prefetch, + SPV_INTEL_subgroup_matrix_multiply_accumulate, + SPV_INTEL_subgroups, + SPV_INTEL_task_sequence, + SPV_INTEL_tensor_float32_conversion, + SPV_INTEL_ternary_bitwise_function, + SPV_INTEL_unstructured_loop_controls, + SPV_INTEL_usm_storage_classes, + SPV_INTEL_variable_length_array, + SPV_INTEL_vector_compute, + SPV_KHR_16bit_storage, + SPV_KHR_8bit_storage, + SPV_KHR_bfloat16, + SPV_KHR_bit_instructions, + SPV_KHR_compute_shader_derivatives, + SPV_KHR_cooperative_matrix, + SPV_KHR_device_group, + SPV_KHR_expect_assume, + SPV_KHR_float_controls, + SPV_KHR_float_controls2, + SPV_KHR_fragment_shader_barycentric, + SPV_KHR_fragment_shading_rate, + SPV_KHR_integer_dot_product, + SPV_KHR_multiview, + SPV_KHR_physical_storage_buffer, + SPV_KHR_post_depth_coverage, + SPV_KHR_quad_control, + SPV_KHR_ray_cull_mask, + SPV_KHR_ray_query, + SPV_KHR_ray_tracing, + SPV_KHR_ray_tracing_position_fetch, + SPV_KHR_shader_atomic_counter_ops, + SPV_KHR_shader_ballot, + SPV_KHR_shader_clock, + SPV_KHR_shader_draw_parameters, + SPV_KHR_subgroup_rotate, + SPV_KHR_subgroup_vote, + SPV_KHR_uniform_group_instructions, + SPV_KHR_untyped_pointers, + SPV_KHR_variable_pointers, + SPV_KHR_vulkan_memory_model, + SPV_KHR_workgroup_memory_explicit_layout, + SPV_NV_bindless_texture, + SPV_NV_cluster_acceleration_structure, + SPV_NV_compute_shader_derivatives, + SPV_NV_cooperative_matrix, + SPV_NV_cooperative_matrix2, + SPV_NV_cooperative_vector, + SPV_NV_displacement_micromap, + SPV_NV_fragment_shader_barycentric, + SPV_NV_geometry_shader_passthrough, + SPV_NV_linear_swept_spheres, + SPV_NV_mesh_shader, + SPV_NV_raw_access_chains, + SPV_NV_ray_tracing, + SPV_NV_ray_tracing_motion_blur, + SPV_NV_sample_mask_override_coverage, + SPV_NV_shader_atomic_fp16_vector, + SPV_NV_shader_image_footprint, + SPV_NV_shader_invocation_reorder, + SPV_NV_shader_sm_builtins, + SPV_NV_shader_subgroup_partitioned, + SPV_NV_shading_rate, + SPV_NV_stereo_view_rendering, + SPV_NV_tensor_addressing, + SPV_NV_viewport_array2, + SPV_NVX_multiview_per_view_attributes, + SPV_QCOM_cooperative_matrix_conversion, + SPV_QCOM_image_processing, + SPV_QCOM_image_processing2, + SPV_QCOM_tile_shading, + stencil_export_ext, + storage_buffer16bit_access, + storage_buffer8bit_access, + storage_buffer_array_dynamic_indexing, + storage_buffer_array_non_uniform_indexing, + storage_image_array_dynamic_indexing, + storage_image_array_non_uniform_indexing, + storage_image_extended_formats, + storage_image_multisample, + storage_image_read_without_format, + storage_image_write_without_format, + storage_input_output16, storage_push_constant16, + storage_push_constant8, + storage_tensor_array_dynamic_indexing_arm, + storage_tensor_array_non_uniform_indexing_arm, + storage_texel_buffer_array_dynamic_indexing, + storage_texel_buffer_array_non_uniform_indexing, + subgroup2d_block_iointel, + subgroup2d_block_transform_intel, + subgroup2d_block_transpose_intel, + subgroup_avc_motion_estimation_chroma_intel, + subgroup_avc_motion_estimation_intel, + subgroup_avc_motion_estimation_intra_intel, + subgroup_ballot_khr, + subgroup_buffer_block_iointel, + subgroup_buffer_prefetch_intel, + subgroup_dispatch, + subgroup_image_block_iointel, + subgroup_image_media_block_iointel, + subgroup_matrix_multiply_accumulate_intel, + subgroup_shuffle_intel, + subgroup_vote_khr, + task_sequence_intel, + tensor_addressing_nv, + tensor_float32rounding_intel, + tensors_arm, + ternary_bitwise_function_intel, + tessellation, + tessellation_point_size, + texture_block_match2qcom, + texture_block_match_qcom, + texture_box_filter_qcom, + texture_sample_weighted_qcom, + tile_image_color_read_access_ext, + tile_image_depth_read_access_ext, + tile_image_stencil_read_access_ext, + tile_shading_qcom, + transform_feedback, + uniform_and_storage_buffer16bit_access, + uniform_and_storage_buffer8bit_access, + uniform_buffer_array_dynamic_indexing, + uniform_buffer_array_non_uniform_indexing, + uniform_decoration, + uniform_texel_buffer_array_dynamic_indexing, + uniform_texel_buffer_array_non_uniform_indexing, + unstructured_loop_controls_intel, + untyped_pointers_khr, + usm_storage_classes_intel, v1_0, v1_1, v1_2, @@ -18,8 +415,17 @@ pub const Feature = enum { v1_4, v1_5, v1_6, + variable_length_array_intel, variable_pointers, + variable_pointers_storage_buffer, vector16, + vector_any_intel, + vector_compute_intel, + vulkan_memory_model, + vulkan_memory_model_device_scope, + workgroup_memory_explicit_layout16bit_access_khr, + workgroup_memory_explicit_layout8bit_access_khr, + workgroup_memory_explicit_layout_khr, }; pub const featureSet = CpuFeature.FeatureSetFns(Feature).featureSet; @@ -32,106 +438,2866 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".fields.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.arbitrary_precision_integers)] = .{ + result[@intFromEnum(Feature.addresses)] = .{ .llvm_name = null, - .description = "Enable SPV_INTEL_arbitrary_precision_integers extension and the ArbitraryPrecisionIntegersINTEL capability", + .description = "Enable addresses Capability.", .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.arbitrary_precision_fixed_point_intel)] = .{ + .llvm_name = null, + .description = "Enable arbitrary_precision_fixed_point_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_arbitrary_precision_fixed_point, + .v1_0, + }), + }; + result[@intFromEnum(Feature.arbitrary_precision_floating_point_intel)] = .{ + .llvm_name = null, + .description = "Enable arbitrary_precision_floating_point_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_arbitrary_precision_floating_point, + .v1_0, + }), + }; + result[@intFromEnum(Feature.arbitrary_precision_integers_intel)] = .{ + .llvm_name = null, + .description = "Enable arbitrary_precision_integers_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_arbitrary_precision_integers, + .v1_0, + }), + }; + result[@intFromEnum(Feature.arithmetic_fence_ext)] = .{ + .llvm_name = null, + .description = "Enable arithmetic_fence_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_arithmetic_fence, + .v1_0, + }), + }; + result[@intFromEnum(Feature.asm_intel)] = .{ + .llvm_name = null, + .description = "Enable asm_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_inline_assembly, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float16add_ext)] = .{ + .llvm_name = null, + .description = "Enable atomic_float16add_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_atomic_float16_add, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float16min_max_ext)] = .{ + .llvm_name = null, + .description = "Enable atomic_float16min_max_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_atomic_float_min_max, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float16vector_nv)] = .{ + .llvm_name = null, + .description = "Enable atomic_float16vector_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_shader_atomic_fp16_vector, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float32add_ext)] = .{ + .llvm_name = null, + .description = "Enable atomic_float32add_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_atomic_float_add, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float32min_max_ext)] = .{ + .llvm_name = null, + .description = "Enable atomic_float32min_max_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_atomic_float_min_max, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float64add_ext)] = .{ + .llvm_name = null, + .description = "Enable atomic_float64add_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_atomic_float_add, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_float64min_max_ext)] = .{ + .llvm_name = null, + .description = "Enable atomic_float64min_max_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_atomic_float_min_max, + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_storage)] = .{ + .llvm_name = null, + .description = "Enable atomic_storage Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.atomic_storage_ops)] = .{ + .llvm_name = null, + .description = "Enable atomic_storage_ops Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_shader_atomic_counter_ops, + .v1_0, + }), + }; + result[@intFromEnum(Feature.b_float16conversion_intel)] = .{ + .llvm_name = null, + .description = "Enable b_float16conversion_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_bfloat16_conversion, + .v1_0, + }), + }; + result[@intFromEnum(Feature.b_float16cooperative_matrix_khr)] = .{ + .llvm_name = null, + .description = "Enable b_float16cooperative_matrix_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_bfloat16, + .v1_0, + }), + }; + result[@intFromEnum(Feature.b_float16dot_product_khr)] = .{ + .llvm_name = null, + .description = "Enable b_float16dot_product_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_bfloat16, + .v1_0, + }), + }; + result[@intFromEnum(Feature.b_float16type_khr)] = .{ + .llvm_name = null, + .description = "Enable b_float16type_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_bfloat16, + .v1_0, + }), + }; + result[@intFromEnum(Feature.bindless_images_intel)] = .{ + .llvm_name = null, + .description = "Enable bindless_images_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_bindless_images, + .v1_0, + }), + }; + result[@intFromEnum(Feature.bindless_texture_nv)] = .{ + .llvm_name = null, + .description = "Enable bindless_texture_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_bindless_texture, + .v1_0, + }), + }; + result[@intFromEnum(Feature.bit_instructions)] = .{ + .llvm_name = null, + .description = "Enable bit_instructions Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_bit_instructions, + .v1_0, + }), + }; + result[@intFromEnum(Feature.blocking_pipes_intel)] = .{ + .llvm_name = null, + .description = "Enable blocking_pipes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_blocking_pipes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cache_controls_intel)] = .{ + .llvm_name = null, + .description = "Enable cache_controls_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_cache_controls, + .v1_0, + }), + }; + result[@intFromEnum(Feature.clip_distance)] = .{ + .llvm_name = null, + .description = "Enable clip_distance Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.compute_derivative_group_linear_khr)] = .{ + .llvm_name = null, + .description = "Enable compute_derivative_group_linear_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_compute_shader_derivatives, + .SPV_NV_compute_shader_derivatives, + .v1_0, + }), + }; + result[@intFromEnum(Feature.compute_derivative_group_quads_khr)] = .{ + .llvm_name = null, + .description = "Enable compute_derivative_group_quads_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_compute_shader_derivatives, + .SPV_NV_compute_shader_derivatives, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_block_loads_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_block_loads_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_matrix2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_conversion_qcom)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_conversion_qcom Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_QCOM_cooperative_matrix_conversion, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_conversions_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_conversions_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_matrix2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_khr)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_cooperative_matrix, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_layouts_arm)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_layouts_arm Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_ARM_cooperative_matrix_layouts, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_matrix, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_per_element_operations_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_per_element_operations_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_matrix2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_reductions_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_reductions_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_matrix2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_matrix_tensor_addressing_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_matrix_tensor_addressing_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_matrix2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_vector_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_vector_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_vector, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cooperative_vector_training_nv)] = .{ + .llvm_name = null, + .description = "Enable cooperative_vector_training_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cooperative_vector, + .v1_0, + }), + }; + result[@intFromEnum(Feature.core_builtins_arm)] = .{ + .llvm_name = null, + .description = "Enable core_builtins_arm Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_ARM_core_builtins, + .v1_0, + }), + }; + result[@intFromEnum(Feature.cull_distance)] = .{ + .llvm_name = null, + .description = "Enable cull_distance Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.debug_info_module_intel)] = .{ + .llvm_name = null, + .description = "Enable debug_info_module_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_debug_module, + .v1_0, + }), + }; + result[@intFromEnum(Feature.demote_to_helper_invocation)] = .{ + .llvm_name = null, + .description = "Enable demote_to_helper_invocation Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_demote_to_helper_invocation, + .v1_6, + }), + }; + result[@intFromEnum(Feature.denorm_flush_to_zero)] = .{ + .llvm_name = null, + .description = "Enable denorm_flush_to_zero Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_float_controls, + .v1_4, + }), + }; + result[@intFromEnum(Feature.denorm_preserve)] = .{ + .llvm_name = null, + .description = "Enable denorm_preserve Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_float_controls, + .v1_4, + }), + }; + result[@intFromEnum(Feature.derivative_control)] = .{ + .llvm_name = null, + .description = "Enable derivative_control Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.device_enqueue)] = .{ + .llvm_name = null, + .description = "Enable device_enqueue Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.device_group)] = .{ + .llvm_name = null, + .description = "Enable device_group Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_device_group, + .v1_3, + }), + }; + result[@intFromEnum(Feature.displacement_micromap_nv)] = .{ + .llvm_name = null, + .description = "Enable displacement_micromap_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_displacement_micromap, + .v1_0, + }), + }; + result[@intFromEnum(Feature.dot_product)] = .{ + .llvm_name = null, + .description = "Enable dot_product Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_integer_dot_product, + .v1_6, + }), + }; + result[@intFromEnum(Feature.dot_product_input4x8bit)] = .{ + .llvm_name = null, + .description = "Enable dot_product_input4x8bit Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_integer_dot_product, + .v1_6, + }), + }; + result[@intFromEnum(Feature.dot_product_input4x8bit_packed)] = .{ + .llvm_name = null, + .description = "Enable dot_product_input4x8bit_packed Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_integer_dot_product, + .v1_6, + }), + }; + result[@intFromEnum(Feature.dot_product_input_all)] = .{ + .llvm_name = null, + .description = "Enable dot_product_input_all Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_integer_dot_product, + .v1_6, + }), + }; + result[@intFromEnum(Feature.draw_parameters)] = .{ + .llvm_name = null, + .description = "Enable draw_parameters Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_shader_draw_parameters, + .v1_3, + }), + }; + result[@intFromEnum(Feature.expect_assume_khr)] = .{ + .llvm_name = null, + .description = "Enable expect_assume_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_expect_assume, + .v1_0, + }), + }; + result[@intFromEnum(Feature.float16)] = .{ + .llvm_name = null, + .description = "Enable float16 Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.float16buffer)] = .{ + .llvm_name = null, + .description = "Enable float16buffer Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.float16image_amd)] = .{ + .llvm_name = null, + .description = "Enable float16image_amd Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_AMD_gpu_shader_half_float_fetch, + .v1_0, + }), + }; + result[@intFromEnum(Feature.float64)] = .{ + .llvm_name = null, + .description = "Enable float64 Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.float8cooperative_matrix_ext)] = .{ + .llvm_name = null, + .description = "Enable float8cooperative_matrix_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_float8, + .v1_0, + }), + }; + result[@intFromEnum(Feature.float8ext)] = .{ + .llvm_name = null, + .description = "Enable float8ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_float8, + .v1_0, + }), + }; + result[@intFromEnum(Feature.float_controls2)] = .{ + .llvm_name = null, + .description = "Enable float_controls2 Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_float_controls2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.floating_point_mode_intel)] = .{ + .llvm_name = null, + .description = "Enable floating_point_mode_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_float_controls2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fp_fast_math_mode_intel)] = .{ + .llvm_name = null, + .description = "Enable fp_fast_math_mode_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fp_fast_math_mode, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fp_max_error_intel)] = .{ + .llvm_name = null, + .description = "Enable fp_max_error_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fp_max_error, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_argument_interfaces_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_argument_interfaces_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_argument_interfaces, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_buffer_location_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_buffer_location_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_buffer_location, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_cluster_attributes_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_cluster_attributes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_cluster_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_cluster_attributes_v2intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_cluster_attributes_v2intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_cluster_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_invocation_pipelining_attributes_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_invocation_pipelining_attributes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_invocation_pipelining_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_kernel_attributes_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_kernel_attributes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_kernel_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_kernel_attributesv2intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_kernel_attributesv2intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_kernel_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_latency_control_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_latency_control_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_latency_control, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_loop_controls_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_loop_controls_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_loop_controls, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_memory_accesses_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_memory_accesses_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_memory_accesses, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_memory_attributes_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_memory_attributes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_memory_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpga_reg_intel)] = .{ + .llvm_name = null, + .description = "Enable fpga_reg_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_reg, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fpgadsp_control_intel)] = .{ + .llvm_name = null, + .description = "Enable fpgadsp_control_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_fpga_dsp_control, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_barycentric_khr)] = .{ + .llvm_name = null, + .description = "Enable fragment_barycentric_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_fragment_shader_barycentric, + .SPV_NV_fragment_shader_barycentric, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_density_ext)] = .{ + .llvm_name = null, + .description = "Enable fragment_density_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_fragment_invocation_density, + .SPV_NV_shading_rate, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_fully_covered_ext)] = .{ + .llvm_name = null, + .description = "Enable fragment_fully_covered_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_fragment_fully_covered, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_mask_amd)] = .{ + .llvm_name = null, + .description = "Enable fragment_mask_amd Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_AMD_shader_fragment_mask, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_shader_pixel_interlock_ext)] = .{ + .llvm_name = null, + .description = "Enable fragment_shader_pixel_interlock_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_fragment_shader_interlock, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_shader_sample_interlock_ext)] = .{ + .llvm_name = null, + .description = "Enable fragment_shader_sample_interlock_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_fragment_shader_interlock, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_shader_shading_rate_interlock_ext)] = .{ + .llvm_name = null, + .description = "Enable fragment_shader_shading_rate_interlock_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_fragment_shader_interlock, + .v1_0, + }), + }; + result[@intFromEnum(Feature.fragment_shading_rate_khr)] = .{ + .llvm_name = null, + .description = "Enable fragment_shading_rate_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_fragment_shading_rate, + .v1_0, + }), + }; + result[@intFromEnum(Feature.function_float_control_intel)] = .{ + .llvm_name = null, + .description = "Enable function_float_control_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_float_controls2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.function_pointers_intel)] = .{ + .llvm_name = null, + .description = "Enable function_pointers_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_function_pointers, + .v1_0, + }), + }; + result[@intFromEnum(Feature.function_variants_intel)] = .{ + .llvm_name = null, + .description = "Enable function_variants_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_function_variants, + .v1_0, + }), + }; + result[@intFromEnum(Feature.generic_pointer)] = .{ + .llvm_name = null, + .description = "Enable generic_pointer Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.geometry)] = .{ + .llvm_name = null, + .description = "Enable geometry Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.geometry_point_size)] = .{ + .llvm_name = null, + .description = "Enable geometry_point_size Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.geometry_shader_passthrough_nv)] = .{ + .llvm_name = null, + .description = "Enable geometry_shader_passthrough_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_geometry_shader_passthrough, + .v1_0, + }), + }; + result[@intFromEnum(Feature.geometry_streams)] = .{ + .llvm_name = null, + .description = "Enable geometry_streams Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.global_variable_fpga_decorations_intel)] = .{ + .llvm_name = null, + .description = "Enable global_variable_fpga_decorations_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_global_variable_fpga_decorations, + .v1_0, + }), + }; + result[@intFromEnum(Feature.global_variable_host_access_intel)] = .{ + .llvm_name = null, + .description = "Enable global_variable_host_access_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_global_variable_host_access, + .v1_0, + }), + }; + result[@intFromEnum(Feature.graph_arm)] = .{ + .llvm_name = null, + .description = "Enable graph_arm Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_ARM_graph, + .v1_0, + }), + }; + result[@intFromEnum(Feature.group_non_uniform)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_arithmetic)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_arithmetic Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_ballot)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_ballot Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_clustered)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_clustered Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_partitioned_nv)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_partitioned_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_shader_subgroup_partitioned, + .v1_0, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_quad)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_quad Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_rotate_khr)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_rotate_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_subgroup_rotate, + .v1_0, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_shuffle)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_shuffle Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_shuffle_relative)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_shuffle_relative Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_non_uniform_vote)] = .{ + .llvm_name = null, + .description = "Enable group_non_uniform_vote Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_3, + }), + }; + result[@intFromEnum(Feature.group_uniform_arithmetic_khr)] = .{ + .llvm_name = null, + .description = "Enable group_uniform_arithmetic_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_uniform_group_instructions, + .v1_0, + }), + }; + result[@intFromEnum(Feature.groups)] = .{ + .llvm_name = null, + .description = "Enable groups Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_AMD_shader_ballot, + .v1_0, + }), + }; + result[@intFromEnum(Feature.image1d)] = .{ + .llvm_name = null, + .description = "Enable image1d Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_basic)] = .{ + .llvm_name = null, + .description = "Enable image_basic Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_buffer)] = .{ + .llvm_name = null, + .description = "Enable image_buffer Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_cube_array)] = .{ + .llvm_name = null, + .description = "Enable image_cube_array Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_footprint_nv)] = .{ + .llvm_name = null, + .description = "Enable image_footprint_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_shader_image_footprint, + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_gather_bias_lod_amd)] = .{ + .llvm_name = null, + .description = "Enable image_gather_bias_lod_amd Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_AMD_texture_gather_bias_lod, + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_gather_extended)] = .{ + .llvm_name = null, + .description = "Enable image_gather_extended Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_mipmap)] = .{ + .llvm_name = null, + .description = "Enable image_mipmap Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_ms_array)] = .{ + .llvm_name = null, + .description = "Enable image_ms_array Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_query)] = .{ + .llvm_name = null, + .description = "Enable image_query Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_read_write)] = .{ + .llvm_name = null, + .description = "Enable image_read_write Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_read_write_lod_amd)] = .{ + .llvm_name = null, + .description = "Enable image_read_write_lod_amd Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_AMD_shader_image_load_store_lod, + .v1_0, + }), + }; + result[@intFromEnum(Feature.image_rect)] = .{ + .llvm_name = null, + .description = "Enable image_rect Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.indirect_references_intel)] = .{ + .llvm_name = null, + .description = "Enable indirect_references_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_function_pointers, + .v1_0, + }), + }; + result[@intFromEnum(Feature.input_attachment)] = .{ + .llvm_name = null, + .description = "Enable input_attachment Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.input_attachment_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable input_attachment_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.input_attachment_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable input_attachment_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.int16)] = .{ + .llvm_name = null, + .description = "Enable int16 Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.int4cooperative_matrix_intel)] = .{ + .llvm_name = null, + .description = "Enable int4cooperative_matrix_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_int4, + .v1_0, + }), + }; + result[@intFromEnum(Feature.int4type_intel)] = .{ + .llvm_name = null, + .description = "Enable int4type_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_int4, + .v1_0, + }), + }; + result[@intFromEnum(Feature.int64)] = .{ + .llvm_name = null, + .description = "Enable int64 Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.int64atomics)] = .{ + .llvm_name = null, + .description = "Enable int64atomics Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.int64image_ext)] = .{ + .llvm_name = null, + .description = "Enable int64image_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_image_int64, + .v1_0, + }), + }; + result[@intFromEnum(Feature.int8)] = .{ + .llvm_name = null, + .description = "Enable int8 Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.integer_functions2intel)] = .{ + .llvm_name = null, + .description = "Enable integer_functions2intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_shader_integer_functions2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.interpolation_function)] = .{ + .llvm_name = null, + .description = "Enable interpolation_function Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.io_pipes_intel)] = .{ + .llvm_name = null, + .description = "Enable io_pipes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_io_pipes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.kernel)] = .{ + .llvm_name = null, + .description = "Enable kernel Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.kernel_attributes_intel)] = .{ + .llvm_name = null, + .description = "Enable kernel_attributes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_kernel_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.linkage)] = .{ + .llvm_name = null, + .description = "Enable linkage Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.literal_sampler)] = .{ + .llvm_name = null, + .description = "Enable literal_sampler Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.long_composites_intel)] = .{ + .llvm_name = null, + .description = "Enable long_composites_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_long_composites, + .v1_0, + }), + }; + result[@intFromEnum(Feature.loop_fuse_intel)] = .{ + .llvm_name = null, + .description = "Enable loop_fuse_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_loop_fuse, + .v1_0, + }), + }; + result[@intFromEnum(Feature.masked_gather_scatter_intel)] = .{ + .llvm_name = null, + .description = "Enable masked_gather_scatter_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_masked_gather_scatter, + .v1_0, + }), + }; + result[@intFromEnum(Feature.matrix)] = .{ + .llvm_name = null, + .description = "Enable matrix Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.memory_access_aliasing_intel)] = .{ + .llvm_name = null, + .description = "Enable memory_access_aliasing_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_memory_access_aliasing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.mesh_shading_ext)] = .{ + .llvm_name = null, + .description = "Enable mesh_shading_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_mesh_shader, + .v1_0, + }), + }; + result[@intFromEnum(Feature.mesh_shading_nv)] = .{ + .llvm_name = null, + .description = "Enable mesh_shading_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_mesh_shader, + .v1_0, + }), + }; + result[@intFromEnum(Feature.min_lod)] = .{ + .llvm_name = null, + .description = "Enable min_lod Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.multi_view)] = .{ + .llvm_name = null, + .description = "Enable multi_view Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_multiview, + .v1_3, + }), + }; + result[@intFromEnum(Feature.multi_viewport)] = .{ + .llvm_name = null, + .description = "Enable multi_viewport Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.named_barrier)] = .{ + .llvm_name = null, + .description = "Enable named_barrier Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_1, + }), + }; + result[@intFromEnum(Feature.opt_none_ext)] = .{ + .llvm_name = null, + .description = "Enable opt_none_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_optnone, + .SPV_INTEL_optnone, + .v1_0, + }), + }; + result[@intFromEnum(Feature.per_view_attributes_nv)] = .{ + .llvm_name = null, + .description = "Enable per_view_attributes_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NVX_multiview_per_view_attributes, + .v1_0, + }), + }; + result[@intFromEnum(Feature.physical_storage_buffer_addresses)] = .{ + .llvm_name = null, + .description = "Enable physical_storage_buffer_addresses Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_physical_storage_buffer, + .SPV_KHR_physical_storage_buffer, + .v1_5, + }), + }; + result[@intFromEnum(Feature.pipe_storage)] = .{ + .llvm_name = null, + .description = "Enable pipe_storage Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_1, + }), + }; + result[@intFromEnum(Feature.pipes)] = .{ + .llvm_name = null, + .description = "Enable pipes Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.quad_control_khr)] = .{ + .llvm_name = null, + .description = "Enable quad_control_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_quad_control, + .v1_0, + }), + }; + result[@intFromEnum(Feature.raw_access_chains_nv)] = .{ + .llvm_name = null, + .description = "Enable raw_access_chains_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_raw_access_chains, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_cull_mask_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_cull_mask_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_cull_mask, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_query_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_query_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_query, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_query_position_fetch_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_query_position_fetch_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_tracing_position_fetch, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_query_provisional_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_query_provisional_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_query, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_cluster_acceleration_structure_nv)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_cluster_acceleration_structure_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_cluster_acceleration_structure, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_displacement_micromap_nv)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_displacement_micromap_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_displacement_micromap, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_tracing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_linear_swept_spheres_geometry_nv)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_linear_swept_spheres_geometry_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_linear_swept_spheres, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_motion_blur_nv)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_motion_blur_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_ray_tracing_motion_blur, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_nv)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_ray_tracing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_opacity_micromap_ext)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_opacity_micromap_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_opacity_micromap, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_position_fetch_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_position_fetch_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_tracing_position_fetch, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_provisional_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_provisional_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_tracing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_tracing_spheres_geometry_nv)] = .{ + .llvm_name = null, + .description = "Enable ray_tracing_spheres_geometry_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_linear_swept_spheres, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ray_traversal_primitive_culling_khr)] = .{ + .llvm_name = null, + .description = "Enable ray_traversal_primitive_culling_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_ray_query, + .SPV_KHR_ray_tracing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.register_limits_intel)] = .{ + .llvm_name = null, + .description = "Enable register_limits_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_maximum_registers, + .v1_0, + }), + }; + result[@intFromEnum(Feature.replicated_composites_ext)] = .{ + .llvm_name = null, + .description = "Enable replicated_composites_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_replicated_composites, + .v1_0, + }), + }; + result[@intFromEnum(Feature.round_to_infinity_intel)] = .{ + .llvm_name = null, + .description = "Enable round_to_infinity_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_float_controls2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.rounding_mode_rte)] = .{ + .llvm_name = null, + .description = "Enable rounding_mode_rte Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_float_controls, + .v1_4, + }), + }; + result[@intFromEnum(Feature.rounding_mode_rtz)] = .{ + .llvm_name = null, + .description = "Enable rounding_mode_rtz Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_float_controls, + .v1_4, + }), + }; + result[@intFromEnum(Feature.runtime_aligned_attribute_intel)] = .{ + .llvm_name = null, + .description = "Enable runtime_aligned_attribute_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_runtime_aligned, + .v1_0, + }), + }; + result[@intFromEnum(Feature.runtime_descriptor_array)] = .{ + .llvm_name = null, + .description = "Enable runtime_descriptor_array Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.sample_mask_override_coverage_nv)] = .{ + .llvm_name = null, + .description = "Enable sample_mask_override_coverage_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_sample_mask_override_coverage, + .v1_0, + }), + }; + result[@intFromEnum(Feature.sample_mask_post_depth_coverage)] = .{ + .llvm_name = null, + .description = "Enable sample_mask_post_depth_coverage Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_post_depth_coverage, + .v1_0, + }), + }; + result[@intFromEnum(Feature.sample_rate_shading)] = .{ + .llvm_name = null, + .description = "Enable sample_rate_shading Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.sampled1d)] = .{ + .llvm_name = null, + .description = "Enable sampled1d Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.sampled_buffer)] = .{ + .llvm_name = null, + .description = "Enable sampled_buffer Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.sampled_cube_array)] = .{ + .llvm_name = null, + .description = "Enable sampled_cube_array Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.sampled_image_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable sampled_image_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.sampled_image_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable sampled_image_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.sampled_rect)] = .{ + .llvm_name = null, + .description = "Enable sampled_rect Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader)] = .{ + .llvm_name = null, + .description = "Enable shader Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_clock_khr)] = .{ + .llvm_name = null, + .description = "Enable shader_clock_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_shader_clock, + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_enqueue_amdx)] = .{ + .llvm_name = null, + .description = "Enable shader_enqueue_amdx Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_AMDX_shader_enqueue, + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_invocation_reorder_nv)] = .{ + .llvm_name = null, + .description = "Enable shader_invocation_reorder_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_shader_invocation_reorder, + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_layer)] = .{ + .llvm_name = null, + .description = "Enable shader_layer Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_5, + }), + }; + result[@intFromEnum(Feature.shader_non_uniform)] = .{ + .llvm_name = null, + .description = "Enable shader_non_uniform Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.shader_sm_builtins_nv)] = .{ + .llvm_name = null, + .description = "Enable shader_sm_builtins_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_shader_sm_builtins, + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_stereo_view_nv)] = .{ + .llvm_name = null, + .description = "Enable shader_stereo_view_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_stereo_view_rendering, + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_viewport_index)] = .{ + .llvm_name = null, + .description = "Enable shader_viewport_index Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_5, + }), + }; + result[@intFromEnum(Feature.shader_viewport_index_layer_ext)] = .{ + .llvm_name = null, + .description = "Enable shader_viewport_index_layer_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_viewport_index_layer, + .SPV_NV_viewport_array2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.shader_viewport_mask_nv)] = .{ + .llvm_name = null, + .description = "Enable shader_viewport_mask_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_viewport_array2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.signed_zero_inf_nan_preserve)] = .{ + .llvm_name = null, + .description = "Enable signed_zero_inf_nan_preserve Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_float_controls, + .v1_4, + }), + }; + result[@intFromEnum(Feature.sparse_residency)] = .{ + .llvm_name = null, + .description = "Enable sparse_residency Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.spec_conditional_intel)] = .{ + .llvm_name = null, + .description = "Enable spec_conditional_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_function_variants, + .v1_0, + }), + }; + result[@intFromEnum(Feature.split_barrier_intel)] = .{ + .llvm_name = null, + .description = "Enable split_barrier_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_split_barrier, + .v1_0, + }), + }; + result[@intFromEnum(Feature.SPV_AMD_gpu_shader_half_float_fetch)] = .{ + .llvm_name = null, + .description = "Enable SPV_AMD_gpu_shader_half_float_fetch Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_AMD_shader_ballot)] = .{ + .llvm_name = null, + .description = "Enable SPV_AMD_shader_ballot Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_AMD_shader_fragment_mask)] = .{ + .llvm_name = null, + .description = "Enable SPV_AMD_shader_fragment_mask Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_AMD_shader_image_load_store_lod)] = .{ + .llvm_name = null, + .description = "Enable SPV_AMD_shader_image_load_store_lod Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_AMD_texture_gather_bias_lod)] = .{ + .llvm_name = null, + .description = "Enable SPV_AMD_texture_gather_bias_lod Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_AMDX_shader_enqueue)] = .{ + .llvm_name = null, + .description = "Enable SPV_AMDX_shader_enqueue Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_ARM_cooperative_matrix_layouts)] = .{ + .llvm_name = null, + .description = "Enable SPV_ARM_cooperative_matrix_layouts Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_ARM_core_builtins)] = .{ + .llvm_name = null, + .description = "Enable SPV_ARM_core_builtins Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_ARM_graph)] = .{ + .llvm_name = null, + .description = "Enable SPV_ARM_graph Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_ARM_tensors)] = .{ + .llvm_name = null, + .description = "Enable SPV_ARM_tensors Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_arithmetic_fence)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_arithmetic_fence Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_demote_to_helper_invocation)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_demote_to_helper_invocation Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_descriptor_indexing)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_descriptor_indexing Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_float8)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_float8 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_fragment_fully_covered)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_fragment_fully_covered Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_fragment_invocation_density)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_fragment_invocation_density Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_fragment_shader_interlock)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_fragment_shader_interlock Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_mesh_shader)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_mesh_shader Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_opacity_micromap)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_opacity_micromap Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_optnone)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_optnone Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_physical_storage_buffer)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_physical_storage_buffer Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_replicated_composites)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_replicated_composites Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_atomic_float16_add)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_atomic_float16_add Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_atomic_float_add)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_atomic_float_add Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_atomic_float_min_max)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_atomic_float_min_max Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_image_int64)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_image_int64 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_stencil_export)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_stencil_export Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_tile_image)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_tile_image Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_EXT_shader_viewport_index_layer)] = .{ + .llvm_name = null, + .description = "Enable SPV_EXT_shader_viewport_index_layer Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_2d_block_io)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_2d_block_io Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_arbitrary_precision_fixed_point)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_arbitrary_precision_fixed_point Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_arbitrary_precision_floating_point)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_arbitrary_precision_floating_point Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_arbitrary_precision_integers)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_arbitrary_precision_integers Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_bfloat16_conversion)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_bfloat16_conversion Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_bindless_images)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_bindless_images Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_blocking_pipes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_blocking_pipes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_cache_controls)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_cache_controls Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_debug_module)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_debug_module Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_device_side_avc_motion_estimation)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_device_side_avc_motion_estimation Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_float_controls2)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_float_controls2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fp_fast_math_mode)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fp_fast_math_mode Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fp_max_error)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fp_max_error Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_argument_interfaces)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_argument_interfaces Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_buffer_location)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_buffer_location Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_cluster_attributes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_cluster_attributes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_dsp_control)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_dsp_control Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_invocation_pipelining_attributes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_invocation_pipelining_attributes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_latency_control)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_latency_control Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_loop_controls)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_loop_controls Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_memory_accesses)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_memory_accesses Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_memory_attributes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_memory_attributes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_fpga_reg)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_fpga_reg Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_function_pointers)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_function_pointers Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_function_variants)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_function_variants Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_global_variable_fpga_decorations)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_global_variable_fpga_decorations Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_global_variable_host_access)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_global_variable_host_access Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_inline_assembly)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_inline_assembly Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_int4)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_int4 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_io_pipes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_io_pipes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_kernel_attributes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_kernel_attributes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_long_composites)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_long_composites Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_loop_fuse)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_loop_fuse Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_masked_gather_scatter)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_masked_gather_scatter Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_maximum_registers)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_maximum_registers Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_media_block_io)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_media_block_io Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_memory_access_aliasing)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_memory_access_aliasing Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_optnone)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_optnone Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_runtime_aligned)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_runtime_aligned Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_shader_integer_functions2)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_shader_integer_functions2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_split_barrier)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_split_barrier Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_subgroup_buffer_prefetch)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_subgroup_buffer_prefetch Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_subgroup_matrix_multiply_accumulate)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_subgroup_matrix_multiply_accumulate Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_subgroups)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_subgroups Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_task_sequence)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_task_sequence Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_tensor_float32_conversion)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_tensor_float32_conversion Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_ternary_bitwise_function)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_ternary_bitwise_function Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_unstructured_loop_controls)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_unstructured_loop_controls Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_usm_storage_classes)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_usm_storage_classes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_variable_length_array)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_variable_length_array Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_INTEL_vector_compute)] = .{ + .llvm_name = null, + .description = "Enable SPV_INTEL_vector_compute Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_16bit_storage)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_16bit_storage Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_8bit_storage)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_8bit_storage Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_bfloat16)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_bfloat16 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_bit_instructions)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_bit_instructions Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_compute_shader_derivatives)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_compute_shader_derivatives Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_cooperative_matrix)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_cooperative_matrix Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_device_group)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_device_group Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_expect_assume)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_expect_assume Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_float_controls)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_float_controls Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_float_controls2)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_float_controls2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_fragment_shader_barycentric)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_fragment_shader_barycentric Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_fragment_shading_rate)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_fragment_shading_rate Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_integer_dot_product)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_integer_dot_product Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_multiview)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_multiview Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_physical_storage_buffer)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_physical_storage_buffer Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_post_depth_coverage)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_post_depth_coverage Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_quad_control)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_quad_control Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_ray_cull_mask)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_ray_cull_mask Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_ray_query)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_ray_query Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_ray_tracing)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_ray_tracing Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_ray_tracing_position_fetch)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_ray_tracing_position_fetch Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_shader_atomic_counter_ops)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_shader_atomic_counter_ops Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_shader_ballot)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_shader_ballot Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_shader_clock)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_shader_clock Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_shader_draw_parameters)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_shader_draw_parameters Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_subgroup_rotate)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_subgroup_rotate Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_subgroup_vote)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_subgroup_vote Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_uniform_group_instructions)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_uniform_group_instructions Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_untyped_pointers)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_untyped_pointers Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_variable_pointers)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_variable_pointers Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_vulkan_memory_model)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_vulkan_memory_model Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_KHR_workgroup_memory_explicit_layout)] = .{ + .llvm_name = null, + .description = "Enable SPV_KHR_workgroup_memory_explicit_layout Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_bindless_texture)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_bindless_texture Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_cluster_acceleration_structure)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_cluster_acceleration_structure Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_compute_shader_derivatives)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_compute_shader_derivatives Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_cooperative_matrix)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_cooperative_matrix Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_cooperative_matrix2)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_cooperative_matrix2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_cooperative_vector)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_cooperative_vector Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_displacement_micromap)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_displacement_micromap Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_fragment_shader_barycentric)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_fragment_shader_barycentric Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_geometry_shader_passthrough)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_geometry_shader_passthrough Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_linear_swept_spheres)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_linear_swept_spheres Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_mesh_shader)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_mesh_shader Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_raw_access_chains)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_raw_access_chains Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_ray_tracing)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_ray_tracing Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_ray_tracing_motion_blur)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_ray_tracing_motion_blur Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_sample_mask_override_coverage)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_sample_mask_override_coverage Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_shader_atomic_fp16_vector)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_shader_atomic_fp16_vector Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_shader_image_footprint)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_shader_image_footprint Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_shader_invocation_reorder)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_shader_invocation_reorder Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_shader_sm_builtins)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_shader_sm_builtins Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_shader_subgroup_partitioned)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_shader_subgroup_partitioned Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_shading_rate)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_shading_rate Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_stereo_view_rendering)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_stereo_view_rendering Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_tensor_addressing)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_tensor_addressing Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NV_viewport_array2)] = .{ + .llvm_name = null, + .description = "Enable SPV_NV_viewport_array2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_NVX_multiview_per_view_attributes)] = .{ + .llvm_name = null, + .description = "Enable SPV_NVX_multiview_per_view_attributes Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_QCOM_cooperative_matrix_conversion)] = .{ + .llvm_name = null, + .description = "Enable SPV_QCOM_cooperative_matrix_conversion Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_QCOM_image_processing)] = .{ + .llvm_name = null, + .description = "Enable SPV_QCOM_image_processing Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_QCOM_image_processing2)] = .{ + .llvm_name = null, + .description = "Enable SPV_QCOM_image_processing2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.SPV_QCOM_tile_shading)] = .{ + .llvm_name = null, + .description = "Enable SPV_QCOM_tile_shading Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.stencil_export_ext)] = .{ + .llvm_name = null, + .description = "Enable stencil_export_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_stencil_export, + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_buffer16bit_access)] = .{ + .llvm_name = null, + .description = "Enable storage_buffer16bit_access Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_16bit_storage, + .v1_3, + }), + }; + result[@intFromEnum(Feature.storage_buffer8bit_access)] = .{ + .llvm_name = null, + .description = "Enable storage_buffer8bit_access Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_8bit_storage, + .v1_5, + }), + }; + result[@intFromEnum(Feature.storage_buffer_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable storage_buffer_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_buffer_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable storage_buffer_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.storage_image_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable storage_image_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_image_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable storage_image_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.storage_image_extended_formats)] = .{ + .llvm_name = null, + .description = "Enable storage_image_extended_formats Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_image_multisample)] = .{ + .llvm_name = null, + .description = "Enable storage_image_multisample Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_image_read_without_format)] = .{ + .llvm_name = null, + .description = "Enable storage_image_read_without_format Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_image_write_without_format)] = .{ + .llvm_name = null, + .description = "Enable storage_image_write_without_format Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_input_output16)] = .{ + .llvm_name = null, + .description = "Enable storage_input_output16 Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_16bit_storage, + .v1_3, + }), + }; + result[@intFromEnum(Feature.storage_push_constant16)] = .{ + .llvm_name = null, + .description = "Enable storage_push_constant16 Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_16bit_storage, + .v1_3, + }), + }; + result[@intFromEnum(Feature.storage_push_constant8)] = .{ + .llvm_name = null, + .description = "Enable storage_push_constant8 Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_8bit_storage, + .v1_5, + }), + }; + result[@intFromEnum(Feature.storage_tensor_array_dynamic_indexing_arm)] = .{ + .llvm_name = null, + .description = "Enable storage_tensor_array_dynamic_indexing_arm Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_ARM_tensors, + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_tensor_array_non_uniform_indexing_arm)] = .{ + .llvm_name = null, + .description = "Enable storage_tensor_array_non_uniform_indexing_arm Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_ARM_tensors, + .v1_0, + }), + }; + result[@intFromEnum(Feature.storage_texel_buffer_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable storage_texel_buffer_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, .v1_5, }), }; - result[@intFromEnum(Feature.float16)] = .{ + result[@intFromEnum(Feature.storage_texel_buffer_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable storage_texel_buffer_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.subgroup2d_block_iointel)] = .{ .llvm_name = null, - .description = "Enable Float16 capability", + .description = "Enable subgroup2d_block_iointel Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_2d_block_io, .v1_0, }), }; - result[@intFromEnum(Feature.float64)] = .{ + result[@intFromEnum(Feature.subgroup2d_block_transform_intel)] = .{ .llvm_name = null, - .description = "Enable Float64 capability", + .description = "Enable subgroup2d_block_transform_intel Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_2d_block_io, .v1_0, }), }; - result[@intFromEnum(Feature.generic_pointer)] = .{ + result[@intFromEnum(Feature.subgroup2d_block_transpose_intel)] = .{ .llvm_name = null, - .description = "Enable GenericPointer capability", + .description = "Enable subgroup2d_block_transpose_intel Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_2d_block_io, .v1_0, }), }; - result[@intFromEnum(Feature.int64)] = .{ + result[@intFromEnum(Feature.subgroup_avc_motion_estimation_chroma_intel)] = .{ .llvm_name = null, - .description = "Enable Int64 capability", + .description = "Enable subgroup_avc_motion_estimation_chroma_intel Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_device_side_avc_motion_estimation, .v1_0, }), }; - result[@intFromEnum(Feature.storage_push_constant16)] = .{ + result[@intFromEnum(Feature.subgroup_avc_motion_estimation_intel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_avc_motion_estimation_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_device_side_avc_motion_estimation, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_avc_motion_estimation_intra_intel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_avc_motion_estimation_intra_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_device_side_avc_motion_estimation, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_ballot_khr)] = .{ + .llvm_name = null, + .description = "Enable subgroup_ballot_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_shader_ballot, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_buffer_block_iointel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_buffer_block_iointel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_subgroups, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_buffer_prefetch_intel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_buffer_prefetch_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_subgroup_buffer_prefetch, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_dispatch)] = .{ + .llvm_name = null, + .description = "Enable subgroup_dispatch Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_1, + }), + }; + result[@intFromEnum(Feature.subgroup_image_block_iointel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_image_block_iointel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_subgroups, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_image_media_block_iointel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_image_media_block_iointel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_media_block_io, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_matrix_multiply_accumulate_intel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_matrix_multiply_accumulate_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_subgroup_matrix_multiply_accumulate, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_shuffle_intel)] = .{ + .llvm_name = null, + .description = "Enable subgroup_shuffle_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_subgroups, + .v1_0, + }), + }; + result[@intFromEnum(Feature.subgroup_vote_khr)] = .{ + .llvm_name = null, + .description = "Enable subgroup_vote_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_subgroup_vote, + .v1_0, + }), + }; + result[@intFromEnum(Feature.task_sequence_intel)] = .{ + .llvm_name = null, + .description = "Enable task_sequence_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_task_sequence, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tensor_addressing_nv)] = .{ + .llvm_name = null, + .description = "Enable tensor_addressing_nv Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_NV_tensor_addressing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tensor_float32rounding_intel)] = .{ + .llvm_name = null, + .description = "Enable tensor_float32rounding_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_tensor_float32_conversion, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tensors_arm)] = .{ + .llvm_name = null, + .description = "Enable tensors_arm Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_ARM_tensors, + .v1_0, + }), + }; + result[@intFromEnum(Feature.ternary_bitwise_function_intel)] = .{ + .llvm_name = null, + .description = "Enable ternary_bitwise_function_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_ternary_bitwise_function, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tessellation)] = .{ + .llvm_name = null, + .description = "Enable tessellation Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.tessellation_point_size)] = .{ + .llvm_name = null, + .description = "Enable tessellation_point_size Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.texture_block_match2qcom)] = .{ + .llvm_name = null, + .description = "Enable texture_block_match2qcom Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_QCOM_image_processing2, + .v1_0, + }), + }; + result[@intFromEnum(Feature.texture_block_match_qcom)] = .{ + .llvm_name = null, + .description = "Enable texture_block_match_qcom Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_QCOM_image_processing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.texture_box_filter_qcom)] = .{ + .llvm_name = null, + .description = "Enable texture_box_filter_qcom Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_QCOM_image_processing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.texture_sample_weighted_qcom)] = .{ + .llvm_name = null, + .description = "Enable texture_sample_weighted_qcom Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_QCOM_image_processing, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tile_image_color_read_access_ext)] = .{ + .llvm_name = null, + .description = "Enable tile_image_color_read_access_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_tile_image, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tile_image_depth_read_access_ext)] = .{ + .llvm_name = null, + .description = "Enable tile_image_depth_read_access_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_tile_image, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tile_image_stencil_read_access_ext)] = .{ + .llvm_name = null, + .description = "Enable tile_image_stencil_read_access_ext Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_shader_tile_image, + .v1_0, + }), + }; + result[@intFromEnum(Feature.tile_shading_qcom)] = .{ + .llvm_name = null, + .description = "Enable tile_shading_qcom Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_QCOM_tile_shading, + .v1_0, + }), + }; + result[@intFromEnum(Feature.transform_feedback)] = .{ .llvm_name = null, - .description = "Enable SPV_KHR_16bit_storage extension and the StoragePushConstant16 capability", + .description = "Enable transform_feedback Capability.", .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.uniform_and_storage_buffer16bit_access)] = .{ + .llvm_name = null, + .description = "Enable uniform_and_storage_buffer16bit_access Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_16bit_storage, .v1_3, }), }; + result[@intFromEnum(Feature.uniform_and_storage_buffer8bit_access)] = .{ + .llvm_name = null, + .description = "Enable uniform_and_storage_buffer8bit_access Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_8bit_storage, + .v1_5, + }), + }; + result[@intFromEnum(Feature.uniform_buffer_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable uniform_buffer_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_0, + }), + }; + result[@intFromEnum(Feature.uniform_buffer_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable uniform_buffer_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.uniform_decoration)] = .{ + .llvm_name = null, + .description = "Enable uniform_decoration Capability.", + .dependencies = featureSet(&[_]Feature{ + .v1_6, + }), + }; + result[@intFromEnum(Feature.uniform_texel_buffer_array_dynamic_indexing)] = .{ + .llvm_name = null, + .description = "Enable uniform_texel_buffer_array_dynamic_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.uniform_texel_buffer_array_non_uniform_indexing)] = .{ + .llvm_name = null, + .description = "Enable uniform_texel_buffer_array_non_uniform_indexing Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_EXT_descriptor_indexing, + .v1_5, + }), + }; + result[@intFromEnum(Feature.unstructured_loop_controls_intel)] = .{ + .llvm_name = null, + .description = "Enable unstructured_loop_controls_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_unstructured_loop_controls, + .v1_0, + }), + }; + result[@intFromEnum(Feature.untyped_pointers_khr)] = .{ + .llvm_name = null, + .description = "Enable untyped_pointers_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_untyped_pointers, + .v1_0, + }), + }; + result[@intFromEnum(Feature.usm_storage_classes_intel)] = .{ + .llvm_name = null, + .description = "Enable usm_storage_classes_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_usm_storage_classes, + .v1_0, + }), + }; result[@intFromEnum(Feature.v1_0)] = .{ .llvm_name = null, - .description = "Enable version 1.0", + .description = "Enable v1_0 Extension.", .dependencies = featureSet(&[_]Feature{}), }; result[@intFromEnum(Feature.v1_1)] = .{ .llvm_name = null, - .description = "Enable version 1.1", + .description = "Enable v1_1 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.v1_2)] = .{ + .llvm_name = null, + .description = "Enable v1_2 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.v1_3)] = .{ + .llvm_name = null, + .description = "Enable v1_3 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.v1_4)] = .{ + .llvm_name = null, + .description = "Enable v1_4 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.v1_5)] = .{ + .llvm_name = null, + .description = "Enable v1_5 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.v1_6)] = .{ + .llvm_name = null, + .description = "Enable v1_6 Extension.", + .dependencies = featureSet(&[_]Feature{}), + }; + result[@intFromEnum(Feature.variable_length_array_intel)] = .{ + .llvm_name = null, + .description = "Enable variable_length_array_intel Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_variable_length_array, .v1_0, }), }; - result[@intFromEnum(Feature.v1_2)] = .{ + result[@intFromEnum(Feature.variable_pointers)] = .{ .llvm_name = null, - .description = "Enable version 1.2", + .description = "Enable variable_pointers Capability.", .dependencies = featureSet(&[_]Feature{ - .v1_1, + .SPV_KHR_variable_pointers, + .v1_3, }), }; - result[@intFromEnum(Feature.v1_3)] = .{ + result[@intFromEnum(Feature.variable_pointers_storage_buffer)] = .{ .llvm_name = null, - .description = "Enable version 1.3", + .description = "Enable variable_pointers_storage_buffer Capability.", .dependencies = featureSet(&[_]Feature{ - .v1_2, + .SPV_KHR_variable_pointers, + .v1_3, }), }; - result[@intFromEnum(Feature.v1_4)] = .{ + result[@intFromEnum(Feature.vector16)] = .{ .llvm_name = null, - .description = "Enable version 1.4", + .description = "Enable vector16 Capability.", .dependencies = featureSet(&[_]Feature{ - .v1_3, + .v1_0, }), }; - result[@intFromEnum(Feature.v1_5)] = .{ + result[@intFromEnum(Feature.vector_any_intel)] = .{ .llvm_name = null, - .description = "Enable version 1.5", + .description = "Enable vector_any_intel Capability.", .dependencies = featureSet(&[_]Feature{ - .v1_4, + .SPV_INTEL_vector_compute, + .v1_0, }), }; - result[@intFromEnum(Feature.v1_6)] = .{ + result[@intFromEnum(Feature.vector_compute_intel)] = .{ + .llvm_name = null, + .description = "Enable vector_compute_intel Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_INTEL_vector_compute, + .v1_0, + }), + }; + result[@intFromEnum(Feature.vulkan_memory_model)] = .{ .llvm_name = null, - .description = "Enable version 1.6", + .description = "Enable vulkan_memory_model Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_vulkan_memory_model, .v1_5, }), }; - result[@intFromEnum(Feature.variable_pointers)] = .{ + result[@intFromEnum(Feature.vulkan_memory_model_device_scope)] = .{ + .llvm_name = null, + .description = "Enable vulkan_memory_model_device_scope Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_vulkan_memory_model, + .v1_5, + }), + }; + result[@intFromEnum(Feature.workgroup_memory_explicit_layout16bit_access_khr)] = .{ .llvm_name = null, - .description = "Enable SPV_KHR_physical_storage_buffer extension and the PhysicalStorageBufferAddresses capability", + .description = "Enable workgroup_memory_explicit_layout16bit_access_khr Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_workgroup_memory_explicit_layout, .v1_0, }), }; - result[@intFromEnum(Feature.vector16)] = .{ + result[@intFromEnum(Feature.workgroup_memory_explicit_layout8bit_access_khr)] = .{ + .llvm_name = null, + .description = "Enable workgroup_memory_explicit_layout8bit_access_khr Capability.", + .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_workgroup_memory_explicit_layout, + .v1_0, + }), + }; + result[@intFromEnum(Feature.workgroup_memory_explicit_layout_khr)] = .{ .llvm_name = null, - .description = "Enable Vector16 capability", + .description = "Enable workgroup_memory_explicit_layout_khr Capability.", .dependencies = featureSet(&[_]Feature{ + .SPV_KHR_workgroup_memory_explicit_layout, .v1_0, }), }; diff --git a/lib/std/builtin.zig b/lib/std/builtin.zig index a646e9ad8013..81f3caa017b7 100644 --- a/lib/std/builtin.zig +++ b/lib/std/builtin.zig @@ -166,7 +166,7 @@ pub const CallingConvention = union(enum(u8)) { pub const kernel: CallingConvention = switch (builtin.target.cpu.arch) { .amdgcn => .amdgcn_kernel, .nvptx, .nvptx64 => .nvptx_kernel, - .spirv32, .spirv64 => .spirv_kernel, + .spirv32, .spirv64 => .{ .spirv_kernel = .{ .x = 1, .y = 1, .z = 1 } }, else => unreachable, }; @@ -358,11 +358,13 @@ pub const CallingConvention = union(enum(u8)) { nvptx_device, nvptx_kernel, - // Calling conventions for kernels and shaders on the `spirv`, `spirv32`, and `spirv64` architectures. + // Calling conventions for kernels and shaders on the `spirv32`, and `spirv64` architectures. spirv_device, - spirv_kernel, - spirv_fragment, + spirv_kernel: SpirvKernelOptions, + spirv_fragment: SpirvFragmentOptions, spirv_vertex, + spirv_task: SpirvKernelOptions, + spirv_mesh: SpirvMeshOptions, /// Options shared across most calling conventions. pub const CommonOptions = struct { @@ -471,6 +473,32 @@ pub const CallingConvention = union(enum(u8)) { }; }; + pub const SpirvKernelOptions = struct { x: u32, y: u32, z: u32 }; + + pub const SpirvFragmentOptions = struct { + const DepthAssumption = enum(u2) { + none = 0, + greater = 1, + less = 2, + unchanged = 3, + }; + + pixel_centered_integer: bool = false, + depth_assumption: DepthAssumption = .none, + }; + + pub const SpirvMeshOptions = struct { + const StageOutput = enum(u2) { + output_points = 0, + output_lines = 1, + output_triangles = 2, + }; + + stage_output: StageOutput = .output_triangles, + max_primitives: u32 = 1, + max_vertices: u32 = 3, + }; + /// Options for the `sh_interrupt` calling convention. pub const ShInterruptOptions = struct { /// The boundary the stack is aligned to when the function is called. diff --git a/lib/std/gpu.zig b/lib/std/gpu.zig index d72d298b32d2..91e8188a336f 100644 --- a/lib/std/gpu.zig +++ b/lib/std/gpu.zig @@ -22,7 +22,7 @@ pub extern const instance_index: u32 addrspace(.input); /// Forms the main linkage for `input` and `output` address spaces. /// `ptr` must be a reference to variable or struct field. -pub fn location(comptime ptr: anytype, comptime loc: u32) void { +pub inline fn location(comptime ptr: anytype, comptime loc: u32) void { asm volatile ( \\OpDecorate %ptr Location $loc : @@ -33,7 +33,7 @@ pub fn location(comptime ptr: anytype, comptime loc: u32) void { /// Forms the main linkage for `input` and `output` address spaces. /// `ptr` must be a reference to variable or struct field. -pub fn binding(comptime ptr: anytype, comptime set: u32, comptime bind: u32) void { +pub inline fn binding(comptime ptr: anytype, comptime set: u32, comptime bind: u32) void { asm volatile ( \\OpDecorate %ptr DescriptorSet $set \\OpDecorate %ptr Binding $bind @@ -43,86 +43,3 @@ pub fn binding(comptime ptr: anytype, comptime set: u32, comptime bind: u32) voi [bind] "c" (bind), ); } - -pub const ExecutionMode = union(Tag) { - /// Sets origin of the framebuffer to the upper-left corner - origin_upper_left, - /// Sets origin of the framebuffer to the lower-left corner - origin_lower_left, - /// Indicates that the fragment shader writes to `frag_depth`, - /// replacing the fixed-function depth value. - depth_replacing, - /// Indicates that per-fragment tests may assume that - /// any `frag_depth` built in-decorated value written by the shader is - /// greater-than-or-equal to the fragment’s interpolated depth value - depth_greater, - /// Indicates that per-fragment tests may assume that - /// any `frag_depth` built in-decorated value written by the shader is - /// less-than-or-equal to the fragment’s interpolated depth value - depth_less, - /// Indicates that per-fragment tests may assume that - /// any `frag_depth` built in-decorated value written by the shader is - /// the same as the fragment’s interpolated depth value - depth_unchanged, - /// Indicates the workgroup size in the x, y, and z dimensions. - local_size: LocalSize, - - pub const Tag = enum(u32) { - origin_upper_left = 7, - origin_lower_left = 8, - depth_replacing = 12, - depth_greater = 14, - depth_less = 15, - depth_unchanged = 16, - local_size = 17, - }; - - pub const LocalSize = struct { x: u32, y: u32, z: u32 }; -}; - -/// Declare the mode entry point executes in. -pub fn executionMode(comptime entry_point: anytype, comptime mode: ExecutionMode) void { - const cc = @typeInfo(@TypeOf(entry_point)).@"fn".calling_convention; - switch (mode) { - .origin_upper_left, - .origin_lower_left, - .depth_replacing, - .depth_greater, - .depth_less, - .depth_unchanged, - => { - if (cc != .spirv_fragment) { - @compileError( - \\invalid execution mode ' - ++ @tagName(mode) ++ - \\' for function with ' - ++ @tagName(cc) ++ - \\' calling convention - ); - } - asm volatile ( - \\OpExecutionMode %entry_point $mode - : - : [entry_point] "" (entry_point), - [mode] "c" (@intFromEnum(mode)), - ); - }, - .local_size => |size| { - if (cc != .spirv_kernel) { - @compileError( - \\invalid execution mode 'local_size' for function with ' - ++ @tagName(cc) ++ - \\' calling convention - ); - } - asm volatile ( - \\OpExecutionMode %entry_point LocalSize $x $y $z - : - : [entry_point] "" (entry_point), - [x] "c" (size.x), - [y] "c" (size.y), - [z] "c" (size.z), - ); - }, - } -} diff --git a/src/InternPool.zig b/src/InternPool.zig index 2a5436787c42..ff28aea6de37 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -4898,12 +4898,19 @@ pub const Index = enum(u32) { type_function: struct { const @"data.flags.has_comptime_bits" = opaque {}; const @"data.flags.has_noalias_bits" = opaque {}; + const @"data.flags.cc_extra_len" = opaque {}; const @"data.params_len" = opaque {}; data: *Tag.TypeFunction, @"trailing.comptime_bits.len": *@"data.flags.has_comptime_bits", @"trailing.noalias_bits.len": *@"data.flags.has_noalias_bits", + @"trailing.cc_bits.len": *@"data.flags.cc_extra_len", @"trailing.param_types.len": *@"data.params_len", - trailing: struct { comptime_bits: []u32, noalias_bits: []u32, param_types: []Index }, + trailing: struct { + comptime_bits: []u32, + noalias_bits: []u32, + cc_bits: []u32, + param_types: []Index, + }, }, undef: DataIsIndex, @@ -5840,6 +5847,7 @@ pub const Tag = enum(u8) { .trailing = struct { param_comptime_bits: ?[]u32, param_noalias_bits: ?[]u32, + param_cc_bits: ?[]u32, param_type: []Index, }, .config = .{ @@ -5847,6 +5855,8 @@ pub const Tag = enum(u8) { .@"trailing.param_comptime_bits.?.len" = .@"(payload.params_len + 31) / 32", .@"trailing.param_noalias_bits.?" = .@"payload.flags.has_noalias_bits", .@"trailing.param_noalias_bits.?.len" = .@"(payload.params_len + 31) / 32", + .@"trailing.param_cc_bits.?" = .@"payload.flags.cc_extra_len != 0", + .@"trailing.param_cc_bits.?.len" = .@"payload.flags.cc_extra_len", .@"trailing.param_type.len" = .@"payload.params_len", }, }, @@ -6053,7 +6063,11 @@ pub const Tag = enum(u8) { /// Trailing: /// 0. comptime_bits: u32, // if has_comptime_bits /// 1. noalias_bits: u32, // if has_noalias_bits - /// 2. param_type: Index for each params_len + /// 2. if cc.tag == .spirv_mesh + /// cc_bits: [2]u32 + /// if cc.tag == .spirv_kernel or cc.tag == .spirv_task + /// cc_bits: [3]u32 + /// 3. param_type: Index for each params_len pub const TypeFunction = struct { params_len: u32, return_type: Index, @@ -6065,8 +6079,9 @@ pub const Tag = enum(u8) { is_generic: bool, has_comptime_bits: bool, has_noalias_bits: bool, + cc_extra_len: u2, is_noinline: bool, - _: u9 = 0, + _: u7 = 0, }; }; @@ -7517,6 +7532,20 @@ fn extraFuncType(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Ke trail_index += 1; break :b x; }; + var cc = type_function.data.flags.cc.unpack(); + switch (cc) { + .spirv_kernel, .spirv_task => |*kernel| { + kernel.x = extra.view().items(.@"0")[trail_index]; + kernel.y = extra.view().items(.@"0")[trail_index + 1]; + kernel.z = extra.view().items(.@"0")[trail_index + 2]; + }, + .spirv_mesh => |*mesh| { + mesh.max_primitives = extra.view().items(.@"0")[trail_index]; + mesh.max_vertices = extra.view().items(.@"0")[trail_index + 1]; + }, + else => {}, + } + trail_index += type_function.data.flags.cc_extra_len; return .{ .param_types = .{ .tid = tid, @@ -7526,7 +7555,7 @@ fn extraFuncType(tid: Zcu.PerThread.Id, extra: Local.Extra, extra_index: u32) Ke .return_type = type_function.data.return_type, .comptime_bits = comptime_bits, .noalias_bits = noalias_bits, - .cc = type_function.data.flags.cc.unpack(), + .cc = cc, .is_var_args = type_function.data.flags.is_var_args, .is_noinline = type_function.data.flags.is_noinline, .is_generic = type_function.data.flags.is_generic, @@ -9161,11 +9190,17 @@ pub fn getFuncType( // ask if it already exists, and if so, revert the lengths of the mutated // arrays. This is similar to what `getOrPutTrailingString` does. const prev_extra_len = extra.mutate.len; + const cc_extra_len: u2 = if (key.cc) |cc| switch (cc) { + .spirv_kernel, .spirv_task => 3, + .spirv_mesh => 2, + else => 0, + } else 0; const params_len: u32 = @intCast(key.param_types.len); try extra.ensureUnusedCapacity(@typeInfo(Tag.TypeFunction).@"struct".fields.len + @intFromBool(key.comptime_bits != 0) + @intFromBool(key.noalias_bits != 0) + + cc_extra_len + params_len); const func_type_extra_index = addExtraAssumeCapacity(extra, Tag.TypeFunction{ @@ -9176,6 +9211,7 @@ pub fn getFuncType( .is_var_args = key.is_var_args, .has_comptime_bits = key.comptime_bits != 0, .has_noalias_bits = key.noalias_bits != 0, + .cc_extra_len = cc_extra_len, .is_generic = key.is_generic, .is_noinline = key.is_noinline, }, @@ -9183,6 +9219,18 @@ pub fn getFuncType( if (key.comptime_bits != 0) extra.appendAssumeCapacity(.{key.comptime_bits}); if (key.noalias_bits != 0) extra.appendAssumeCapacity(.{key.noalias_bits}); + if (key.cc) |cc| switch (cc) { + .spirv_kernel, .spirv_task => |kernel| extra.appendSliceAssumeCapacity(.{&.{ + kernel.x, + kernel.y, + kernel.z, + }}), + .spirv_mesh => |mesh| extra.appendSliceAssumeCapacity(.{&.{ + mesh.max_primitives, + mesh.max_vertices, + }}), + else => {}, + }; extra.appendSliceAssumeCapacity(.{@ptrCast(key.param_types)}); errdefer extra.mutate.len = prev_extra_len; @@ -9437,6 +9485,7 @@ pub fn getFuncDeclIes( .is_var_args = key.is_var_args, .has_comptime_bits = key.comptime_bits != 0, .has_noalias_bits = key.noalias_bits != 0, + .cc_extra_len = 0, .is_generic = key.is_generic, .is_noinline = key.is_noinline, }, @@ -9733,6 +9782,7 @@ pub fn getFuncInstanceIes( .is_var_args = false, .has_comptime_bits = false, .has_noalias_bits = arg.noalias_bits != 0, + .cc_extra_len = 0, .is_generic = false, .is_noinline = arg.is_noinline, }, @@ -11227,7 +11277,8 @@ fn dumpStatsFallible(ip: *const InternPool, arena: Allocator) anyerror!void { break :b @sizeOf(Tag.TypeFunction) + (@sizeOf(Index) * info.params_len) + (@as(u32, 4) * @intFromBool(info.flags.has_comptime_bits)) + - (@as(u32, 4) * @intFromBool(info.flags.has_noalias_bits)); + (@as(u32, 4) * @intFromBool(info.flags.has_noalias_bits)) + + (@as(u32, 4) * info.flags.cc_extra_len); }, .undef => 0, @@ -12975,6 +13026,21 @@ const PackedCallingConvention = packed struct(u18) { .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), .extra = @intFromEnum(pl.mode), }, + std.builtin.CallingConvention.SpirvKernelOptions => .{ + .tag = tag, + .incoming_stack_alignment = .none, // unused + .extra = 0, // unused + }, + std.builtin.CallingConvention.SpirvFragmentOptions => .{ + .tag = tag, + .incoming_stack_alignment = .none, // unused + .extra = @as(u4, @intFromEnum(pl.depth_assumption)) << 1 | @intFromBool(pl.pixel_centered_integer), + }, + std.builtin.CallingConvention.SpirvMeshOptions => .{ + .tag = tag, + .incoming_stack_alignment = .none, // unused + .extra = @intFromEnum(pl.stage_output), + }, std.builtin.CallingConvention.ShInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), @@ -13019,6 +13085,20 @@ const PackedCallingConvention = packed struct(u18) { .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .mode = @enumFromInt(cc.extra), }, + std.builtin.CallingConvention.SpirvKernelOptions => .{ + .x = undefined, // Populated later + .y = undefined, // Populated later + .z = undefined, // Populated later + }, + std.builtin.CallingConvention.SpirvFragmentOptions => .{ + .pixel_centered_integer = @bitCast(@as(u1, @truncate(cc.extra))), + .depth_assumption = @enumFromInt(@as(u2, @truncate(cc.extra >> 1))), + }, + std.builtin.CallingConvention.SpirvMeshOptions => .{ + .stage_output = @enumFromInt(cc.extra), + .max_primitives = undefined, // Populated later + .max_vertices = undefined, // Populated later + }, std.builtin.CallingConvention.ShInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), .save = @enumFromInt(cc.extra), diff --git a/src/Sema.zig b/src/Sema.zig index 4016041d82b5..3598ec4ab44c 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -9151,6 +9151,8 @@ fn callConvIsCallable(cc: std.builtin.CallingConvention.Tag) bool { .spirv_kernel, .spirv_fragment, .spirv_vertex, + .spirv_task, + .spirv_mesh, => false, else => true, @@ -30047,14 +30049,23 @@ fn callconvCoerceAllowed( switch (src_cc) { inline else => |src_data, tag| { const dest_data = @field(dest_cc, @tagName(tag)); - if (@TypeOf(src_data) != void) { + if (@TypeOf(src_data) != void and + @TypeOf(src_data) != std.builtin.CallingConvention.SpirvKernelOptions and + @TypeOf(src_data) != std.builtin.CallingConvention.SpirvMeshOptions and + @TypeOf(src_data) != std.builtin.CallingConvention.SpirvFragmentOptions) + { const default_stack_align = target.stackAlignment(); const src_stack_align = src_data.incoming_stack_alignment orelse default_stack_align; const dest_stack_align = src_data.incoming_stack_alignment orelse default_stack_align; if (dest_stack_align < src_stack_align) return false; } switch (@TypeOf(src_data)) { - void, std.builtin.CallingConvention.CommonOptions => {}, + void, + std.builtin.CallingConvention.CommonOptions, + std.builtin.CallingConvention.SpirvKernelOptions, + std.builtin.CallingConvention.SpirvMeshOptions, + std.builtin.CallingConvention.SpirvFragmentOptions, + => {}, std.builtin.CallingConvention.X86RegparmOptions => { if (src_data.register_params != dest_data.register_params) return false; }, diff --git a/src/Zcu.zig b/src/Zcu.zig index ed1ae0eece2f..c30e51d5bbc4 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -4539,7 +4539,7 @@ pub fn callconvSupported(zcu: *Zcu, cc: std.builtin.CallingConvention) union(enu }, .stage2_spirv => switch (cc) { .spirv_device, .spirv_kernel => true, - .spirv_fragment, .spirv_vertex => target.os.tag == .vulkan or target.os.tag == .opengl, + .spirv_fragment, .spirv_vertex, .spirv_task, .spirv_mesh => target.os.tag == .vulkan or target.os.tag == .opengl, else => false, }, }; diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 6b891c1ab5a9..98b70d979ace 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -11806,7 +11806,11 @@ pub fn toLlvmCallConv(cc: std.builtin.CallingConvention, target: *const std.Targ const llvm_cc = toLlvmCallConvTag(cc, target) orelse return null; const incoming_stack_alignment: ?u64, const register_params: u2 = switch (cc) { inline else => |pl| switch (@TypeOf(pl)) { - void => .{ null, 0 }, + void, + std.builtin.CallingConvention.SpirvKernelOptions, + std.builtin.CallingConvention.SpirvMeshOptions, + std.builtin.CallingConvention.SpirvFragmentOptions, + => .{ null, 0 }, std.builtin.CallingConvention.ArcInterruptOptions, std.builtin.CallingConvention.ArmInterruptOptions, std.builtin.CallingConvention.RiscvInterruptOptions, @@ -11953,6 +11957,8 @@ fn toLlvmCallConvTag(cc_tag: std.builtin.CallingConvention.Tag, target: *const s .spirv_kernel, .spirv_fragment, .spirv_vertex, + .spirv_task, + .spirv_mesh, => null, }; } diff --git a/src/codegen/spirv/Assembler.zig b/src/codegen/spirv/Assembler.zig index a47cd49644f7..ca1483742e69 100644 --- a/src/codegen/spirv/Assembler.zig +++ b/src/codegen/spirv/Assembler.zig @@ -168,14 +168,10 @@ fn processInstruction(ass: *Assembler) !void { return ass.fail(ass.currentToken().start, "cannot set execution mode in assembly", .{}); }, .OpCapability => { - try module.addCapability(@enumFromInt(ass.inst.operands.items[0].value)); - return; + return ass.fail(ass.currentToken().start, "cannot set capability in assembly", .{}); }, .OpExtension => { - const ext_name_offset = ass.inst.operands.items[0].string; - const ext_name = std.mem.sliceTo(ass.inst.string_bytes.items[ext_name_offset..], 0); - try module.addExtension(ext_name); - return; + return ass.fail(ass.currentToken().start, "cannot set extension in assembly", .{}); }, .OpExtInstImport => blk: { const set_name_offset = ass.inst.operands.items[1].string; diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig index c8956a274b11..1458003f38d5 100644 --- a/src/codegen/spirv/CodeGen.zig +++ b/src/codegen/spirv/CodeGen.zig @@ -1425,6 +1425,8 @@ fn resolveType(cg: *CodeGen, ty: Type, repr: Repr) Error!Id { .spirv_fragment, .spirv_vertex, .spirv_device, + .spirv_task, + .spirv_mesh, => {}, else => unreachable, } @@ -2510,13 +2512,11 @@ fn generateTestEntryPoint( // point name is the same as a different OpName. const test_name = try std.fmt.allocPrint(cg.module.arena, "test {s}", .{name}); - const execution_mode: spec.ExecutionModel = switch (target.os.tag) { - .vulkan, .opengl => .gl_compute, - .opencl, .amdhsa => .kernel, - else => unreachable, - }; - - try cg.module.declareEntryPoint(spv_decl_index, test_name, execution_mode, null); + try cg.module.declareEntryPoint( + spv_decl_index, + test_name, + .{ .spirv_kernel = .{ .x = 1, .y = 1, .z = 1 } }, + ); } fn intFromBool(cg: *CodeGen, value: Temporary, result_ty: Type) !Temporary { diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig index c54bc1e5e790..e4c23c73573d 100644 --- a/src/codegen/spirv/Module.zig +++ b/src/codegen/spirv/Module.zig @@ -61,8 +61,8 @@ cache: struct { struct_types: std.ArrayHashMapUnmanaged(StructType, Id, StructType.HashContext, true) = .empty, fn_types: std.ArrayHashMapUnmanaged(FnType, Id, FnType.HashContext, true) = .empty, - capabilities: std.AutoHashMapUnmanaged(spec.Capability, void) = .empty, - extensions: std.StringHashMapUnmanaged(void) = .empty, + capabilities: std.EnumSet(spec.Capability) = .initEmpty(), + extensions: std.EnumSet(spec.Extension) = .initEmpty(), extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, Id) = .empty, decorations: std.AutoHashMapUnmanaged(struct { Id, spec.Decoration }, void) = .empty, builtins: std.AutoHashMapUnmanaged(struct { spec.BuiltIn, spec.StorageClass }, Decl.Index) = .empty, @@ -130,15 +130,10 @@ pub const Decl = struct { end_dep: usize = 0, }; -/// This models a kernel entry point. pub const EntryPoint = struct { - /// The declaration that should be exported. decl_index: Decl.Index, - /// The name of the kernel to be exported. name: []const u8, - /// Calling Convention - exec_model: spec.ExecutionModel, - exec_mode: ?spec.ExecutionMode = null, + cc: std.builtin.CallingConvention, }; const StructType = struct { @@ -229,8 +224,6 @@ pub fn deinit(module: *Module) void { module.cache.array_types.deinit(module.gpa); module.cache.struct_types.deinit(module.gpa); module.cache.fn_types.deinit(module.gpa); - module.cache.capabilities.deinit(module.gpa); - module.cache.extensions.deinit(module.gpa); module.cache.extended_instruction_set.deinit(module.gpa); module.cache.decorations.deinit(module.gpa); module.cache.builtins.deinit(module.gpa); @@ -317,25 +310,108 @@ fn entryPoints(module: *Module) !Section { interface.items.len = 0; seen.setRangeValue(.{ .start = 0, .end = module.decls.items.len }, false); + const exec_model: spec.ExecutionModel = switch (target.os.tag) { + .vulkan, .opengl => switch (entry_point.cc) { + .spirv_vertex => .vertex, + .spirv_fragment => .fragment, + .spirv_kernel => .gl_compute, + .spirv_task => .task_ext, + .spirv_mesh => .mesh_ext, + // TODO: We should integrate with the Linkage capability and export this function + .spirv_device => continue, + else => unreachable, + }, + .opencl => switch (entry_point.cc) { + .spirv_kernel => .kernel, + // TODO: We should integrate with the Linkage capability and export this function + .spirv_device => continue, + else => unreachable, + }, + else => unreachable, + }; try module.addEntryPointDeps(entry_point.decl_index, &seen, &interface); try entry_points.emit(module.gpa, .OpEntryPoint, .{ - .execution_model = entry_point.exec_model, + .execution_model = exec_model, .entry_point = entry_point_id, .name = entry_point.name, .interface = interface.items, }); - if (entry_point.exec_mode == null and entry_point.exec_model == .fragment) { - switch (target.os.tag) { - .vulkan, .opengl => |tag| { + switch (entry_point.cc) { + .spirv_kernel, .spirv_task => |kernel| { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .{ .local_size = .{ + .x_size = kernel.x, + .y_size = kernel.y, + .z_size = kernel.z, + } }, + }); + }, + .spirv_fragment => |fragment| { + if (fragment.pixel_centered_integer and target.os.tag != .vulkan) { try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ .entry_point = entry_point_id, - .mode = if (tag == .vulkan) .origin_upper_left else .origin_lower_left, + .mode = .pixel_center_integer, }); - }, - .opencl => {}, - else => unreachable, - } + } + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = if (target.os.tag == .vulkan) .origin_upper_left else .origin_lower_left, + }); + switch (fragment.depth_assumption) { + .none => {}, + .greater => { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .depth_greater, + }); + }, + .less => { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .depth_less, + }); + }, + .unchanged => { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .depth_unchanged, + }); + }, + } + }, + .spirv_mesh => |mesh| { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .{ .output_vertices = .{ .vertex_count = mesh.max_vertices } }, + }); + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .{ .output_primitives_ext = .{ .primitive_count = mesh.max_primitives } }, + }); + switch (mesh.stage_output) { + .output_points => { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .output_points, + }); + }, + .output_lines => { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .output_lines_ext, + }); + }, + .output_triangles => { + try module.sections.execution_modes.emit(module.gpa, .OpExecutionMode, .{ + .entry_point = entry_point_id, + .mode = .output_triangles_ext, + }); + }, + } + }, + else => {}, } } @@ -355,7 +431,7 @@ pub fn finalize(module: *Module, gpa: Allocator) ![]Word { try module.addCapability(.shader); try module.addCapability(.matrix); if (target.cpu.arch == .spirv64) { - try module.addExtension("SPV_KHR_physical_storage_buffer"); + try module.addExtension(.SPV_KHR_physical_storage_buffer); try module.addCapability(.physical_storage_buffer_addresses); } }, @@ -366,27 +442,24 @@ pub fn finalize(module: *Module, gpa: Allocator) ![]Word { else => unreachable, } if (target.cpu.arch == .spirv64) try module.addCapability(.int64); - if (target.cpu.has(.spirv, .int64)) try module.addCapability(.int64); - if (target.cpu.has(.spirv, .float16)) { - if (target.os.tag == .opencl) try module.addExtension("cl_khr_fp16"); - try module.addCapability(.float16); - } - if (target.cpu.has(.spirv, .float64)) try module.addCapability(.float64); - if (target.cpu.has(.spirv, .generic_pointer)) try module.addCapability(.generic_pointer); - if (target.cpu.has(.spirv, .vector16)) try module.addCapability(.vector16); - if (target.cpu.has(.spirv, .storage_push_constant16)) { - try module.addExtension("SPV_KHR_16bit_storage"); - try module.addCapability(.storage_push_constant16); - } - if (target.cpu.has(.spirv, .arbitrary_precision_integers)) { - try module.addExtension("SPV_INTEL_arbitrary_precision_integers"); - try module.addCapability(.arbitrary_precision_integers_intel); + inline for (@typeInfo(spec.Capability).@"enum".fields) |field| { + if (target.cpu.has(.spirv, std.meta.stringToEnum(std.Target.spirv.Feature, field.name).?)) { + try module.addCapability(@enumFromInt(field.value)); + } } - if (target.cpu.has(.spirv, .variable_pointers)) { - try module.addExtension("SPV_KHR_variable_pointers"); - try module.addCapability(.variable_pointers_storage_buffer); - try module.addCapability(.variable_pointers); + + inline for (@typeInfo(spec.Extension).@"enum".fields) |field| { + const ext: spec.Extension = @enumFromInt(field.value); + switch (ext) { + .v1_0, .v1_1, .v1_2, .v1_3, .v1_4, .v1_5, .v1_6 => continue, + else => { + if (target.cpu.has(.spirv, std.meta.stringToEnum(std.Target.spirv.Feature, field.name).?)) { + try module.addExtension(ext); + } + }, + } } + // These are well supported try module.addCapability(.int8); try module.addCapability(.int16); @@ -479,15 +552,15 @@ pub fn finalize(module: *Module, gpa: Allocator) ![]Word { } pub fn addCapability(module: *Module, cap: spec.Capability) !void { - const entry = try module.cache.capabilities.getOrPut(module.gpa, cap); - if (entry.found_existing) return; + if (module.cache.capabilities.contains(cap)) return; + module.cache.capabilities.insert(cap); try module.sections.capabilities.emit(module.gpa, .OpCapability, .{ .capability = cap }); } -pub fn addExtension(module: *Module, ext: []const u8) !void { - const entry = try module.cache.extensions.getOrPut(module.gpa, ext); - if (entry.found_existing) return; - try module.sections.extensions.emit(module.gpa, .OpExtension, .{ .name = ext }); +pub fn addExtension(module: *Module, ext: spec.Extension) !void { + if (module.cache.extensions.contains(ext)) return; + module.cache.extensions.insert(ext); + try module.sections.extensions.emit(module.gpa, .OpExtension, .{ .name = @tagName(ext) }); } /// Imports or returns the existing id of an extended instruction set @@ -547,7 +620,7 @@ pub fn backingIntBits(module: *Module, bits: u16) struct { u16, bool } { assert(bits != 0); const target = module.zcu.getTarget(); - if (target.cpu.has(.spirv, .arbitrary_precision_integers) and bits <= 32) { + if (target.cpu.has(.spirv, .arbitrary_precision_integers_intel) and bits <= 32) { return .{ bits, false }; } @@ -860,15 +933,12 @@ pub fn declareEntryPoint( module: *Module, decl_index: Decl.Index, name: []const u8, - exec_model: spec.ExecutionModel, - exec_mode: ?spec.ExecutionMode, + cc: std.builtin.CallingConvention, ) !void { const gop = try module.entry_points.getOrPut(module.gpa, module.declPtr(decl_index).result_id); gop.value_ptr.decl_index = decl_index; gop.value_ptr.name = name; - gop.value_ptr.exec_model = exec_model; - // Might've been set by assembler - if (!gop.found_existing) gop.value_ptr.exec_mode = exec_mode; + gop.value_ptr.cc = cc; } pub fn debugName(module: *Module, target: Id, name: []const u8) !void { diff --git a/src/codegen/spirv/spec.zig b/src/codegen/spirv/spec.zig index df5292e3e2da..ec07dd11a5bf 100644 --- a/src/codegen/spirv/spec.zig +++ b/src/codegen/spirv/spec.zig @@ -874,6 +874,7 @@ pub const OperandKind = enum { .{ .name = "HostAccessINTEL", .value = 6188, .parameters = &.{ .host_access_qualifier, .literal_string } }, .{ .name = "InitModeINTEL", .value = 6190, .parameters = &.{.initialization_mode_qualifier} }, .{ .name = "ImplementInRegisterMapINTEL", .value = 6191, .parameters = &.{.literal_integer} }, + .{ .name = "ConditionalINTEL", .value = 6247, .parameters = &.{.id_ref} }, .{ .name = "CacheControlLoadINTEL", .value = 6442, .parameters = &.{ .literal_integer, .load_cache_control } }, .{ .name = "CacheControlStoreINTEL", .value = 6443, .parameters = &.{ .literal_integer, .store_cache_control } }, }, @@ -1144,6 +1145,7 @@ pub const OperandKind = enum { .{ .name = "TextureBoxFilterQCOM", .value = 4485, .parameters = &.{} }, .{ .name = "TextureBlockMatchQCOM", .value = 4486, .parameters = &.{} }, .{ .name = "TileShadingQCOM", .value = 4495, .parameters = &.{} }, + .{ .name = "CooperativeMatrixConversionQCOM", .value = 4496, .parameters = &.{} }, .{ .name = "TextureBlockMatch2QCOM", .value = 4498, .parameters = &.{} }, .{ .name = "Float16ImageAMD", .value = 5008, .parameters = &.{} }, .{ .name = "ImageGatherBiasLodAMD", .value = 5009, .parameters = &.{} }, @@ -1293,6 +1295,8 @@ pub const OperandKind = enum { .{ .name = "Subgroup2DBlockTransposeINTEL", .value = 6230, .parameters = &.{} }, .{ .name = "SubgroupMatrixMultiplyAccumulateINTEL", .value = 6236, .parameters = &.{} }, .{ .name = "TernaryBitwiseFunctionINTEL", .value = 6241, .parameters = &.{} }, + .{ .name = "SpecConditionalINTEL", .value = 6245, .parameters = &.{} }, + .{ .name = "FunctionVariantsINTEL", .value = 6246, .parameters = &.{} }, .{ .name = "GroupUniformArithmeticKHR", .value = 6400, .parameters = &.{} }, .{ .name = "TensorFloat32RoundingINTEL", .value = 6425, .parameters = &.{} }, .{ .name = "MaskedGatherScatterINTEL", .value = 6427, .parameters = &.{} }, @@ -1817,6 +1821,7 @@ pub const Opcode = enum(u16) { OpGroupNonUniformRotateKHR = 4431, OpSubgroupReadInvocationKHR = 4432, OpExtInstWithForwardRefsKHR = 4433, + OpUntypedGroupAsyncCopyKHR = 4434, OpTraceRayKHR = 4445, OpExecuteCallableKHR = 4446, OpConvertUToAccelerationStructureKHR = 4447, @@ -1847,10 +1852,14 @@ pub const Opcode = enum(u16) { OpImageBoxFilterQCOM = 4481, OpImageBlockMatchSSDQCOM = 4482, OpImageBlockMatchSADQCOM = 4483, + OpBitCastArrayQCOM = 4497, OpImageBlockMatchWindowSSDQCOM = 4500, OpImageBlockMatchWindowSADQCOM = 4501, OpImageBlockMatchGatherSSDQCOM = 4502, OpImageBlockMatchGatherSADQCOM = 4503, + OpCompositeConstructCoopMatQCOM = 4540, + OpCompositeExtractCoopMatQCOM = 4541, + OpExtractSubArrayQCOM = 4542, OpGroupIAddNonUniformAMD = 5000, OpGroupFAddNonUniformAMD = 5001, OpGroupFMinNonUniformAMD = 5002, @@ -2053,6 +2062,13 @@ pub const Opcode = enum(u16) { OpSubgroup2DBlockStoreINTEL = 6235, OpSubgroupMatrixMultiplyAccumulateINTEL = 6237, OpBitwiseFunctionINTEL = 6242, + OpConditionalExtensionINTEL = 6248, + OpConditionalEntryPointINTEL = 6249, + OpConditionalCapabilityINTEL = 6250, + OpSpecConstantTargetINTEL = 6251, + OpSpecConstantArchitectureINTEL = 6252, + OpSpecConstantCapabilitiesINTEL = 6253, + OpConditionalCopyObjectINTEL = 6254, OpGroupIMulKHR = 6401, OpGroupFMulKHR = 6402, OpGroupBitwiseAndKHR = 6403, @@ -2380,7 +2396,7 @@ pub const Opcode = enum(u16) { .OpGroupNonUniformAll => struct { id_result_type: Id, id_result: Id, execution: Id, predicate: Id }, .OpGroupNonUniformAny => struct { id_result_type: Id, id_result: Id, execution: Id, predicate: Id }, .OpGroupNonUniformAllEqual => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id }, - .OpGroupNonUniformBroadcast => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, id: Id }, + .OpGroupNonUniformBroadcast => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, invocation_id: Id }, .OpGroupNonUniformBroadcastFirst => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id }, .OpGroupNonUniformBallot => struct { id_result_type: Id, id_result: Id, execution: Id, predicate: Id }, .OpGroupNonUniformInverseBallot => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id }, @@ -2388,7 +2404,7 @@ pub const Opcode = enum(u16) { .OpGroupNonUniformBallotBitCount => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, value: Id }, .OpGroupNonUniformBallotFindLSB => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id }, .OpGroupNonUniformBallotFindMSB => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id }, - .OpGroupNonUniformShuffle => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, id: Id }, + .OpGroupNonUniformShuffle => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, invocation_id: Id }, .OpGroupNonUniformShuffleXor => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, mask: Id }, .OpGroupNonUniformShuffleUp => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, delta: Id }, .OpGroupNonUniformShuffleDown => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, delta: Id }, @@ -2445,6 +2461,7 @@ pub const Opcode = enum(u16) { .OpGroupNonUniformRotateKHR => struct { id_result_type: Id, id_result: Id, execution: Id, value: Id, delta: Id, cluster_size: ?Id = null }, .OpSubgroupReadInvocationKHR => struct { id_result_type: Id, id_result: Id, value: Id, index: Id }, .OpExtInstWithForwardRefsKHR => struct { id_result_type: Id, id_result: Id, set: Id, instruction: LiteralExtInstInteger, id_ref_4: []const Id = &.{} }, + .OpUntypedGroupAsyncCopyKHR => struct { id_result_type: Id, id_result: Id, execution: Id, destination: Id, source: Id, element_num_bytes: Id, num_elements: Id, stride: Id, event: Id, destination_memory_operands: ?MemoryAccess.Extended = null, source_memory_operands: ?MemoryAccess.Extended = null }, .OpTraceRayKHR => struct { accel: Id, ray_flags: Id, cull_mask: Id, sbt_offset: Id, sbt_stride: Id, miss_index: Id, ray_origin: Id, ray_tmin: Id, ray_direction: Id, ray_tmax: Id, payload: Id }, .OpExecuteCallableKHR => struct { sbt_index: Id, callable_data: Id }, .OpConvertUToAccelerationStructureKHR => struct { id_result_type: Id, id_result: Id, accel: Id }, @@ -2475,10 +2492,14 @@ pub const Opcode = enum(u16) { .OpImageBoxFilterQCOM => struct { id_result_type: Id, id_result: Id, texture: Id, coordinates: Id, box_size: Id }, .OpImageBlockMatchSSDQCOM => struct { id_result_type: Id, id_result: Id, target: Id, target_coordinates: Id, reference: Id, reference_coordinates: Id, block_size: Id }, .OpImageBlockMatchSADQCOM => struct { id_result_type: Id, id_result: Id, target: Id, target_coordinates: Id, reference: Id, reference_coordinates: Id, block_size: Id }, + .OpBitCastArrayQCOM => struct { id_result_type: Id, id_result: Id, source_array: Id }, .OpImageBlockMatchWindowSSDQCOM => struct { id_result_type: Id, id_result: Id, target_sampled_image: Id, target_coordinates: Id, reference_sampled_image: Id, reference_coordinates: Id, block_size: Id }, .OpImageBlockMatchWindowSADQCOM => struct { id_result_type: Id, id_result: Id, target_sampled_image: Id, target_coordinates: Id, reference_sampled_image: Id, reference_coordinates: Id, block_size: Id }, .OpImageBlockMatchGatherSSDQCOM => struct { id_result_type: Id, id_result: Id, target_sampled_image: Id, target_coordinates: Id, reference_sampled_image: Id, reference_coordinates: Id, block_size: Id }, .OpImageBlockMatchGatherSADQCOM => struct { id_result_type: Id, id_result: Id, target_sampled_image: Id, target_coordinates: Id, reference_sampled_image: Id, reference_coordinates: Id, block_size: Id }, + .OpCompositeConstructCoopMatQCOM => struct { id_result_type: Id, id_result: Id, source_array: Id }, + .OpCompositeExtractCoopMatQCOM => struct { id_result_type: Id, id_result: Id, source_cooperative_matrix: Id }, + .OpExtractSubArrayQCOM => struct { id_result_type: Id, id_result: Id, source_array: Id, index: Id }, .OpGroupIAddNonUniformAMD => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, x: Id }, .OpGroupFAddNonUniformAMD => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, x: Id }, .OpGroupFMinNonUniformAMD => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, x: Id }, @@ -2681,6 +2702,13 @@ pub const Opcode = enum(u16) { .OpSubgroup2DBlockStoreINTEL => struct { element_size: Id, block_width: Id, block_height: Id, block_count: Id, src_pointer: Id, dst_base_pointer: Id, memory_width: Id, memory_height: Id, memory_pitch: Id, coordinate: Id }, .OpSubgroupMatrixMultiplyAccumulateINTEL => struct { id_result_type: Id, id_result: Id, k_dim: Id, matrix_a: Id, matrix_b: Id, matrix_c: Id, matrix_multiply_accumulate_operands: ?MatrixMultiplyAccumulateOperands = null }, .OpBitwiseFunctionINTEL => struct { id_result_type: Id, id_result: Id, a: Id, b: Id, c: Id, lut_index: Id }, + .OpConditionalExtensionINTEL => struct { condition: Id, name: LiteralString }, + .OpConditionalEntryPointINTEL => struct { condition: Id, execution_model: ExecutionModel, entry_point: Id, name: LiteralString, interface: []const Id = &.{} }, + .OpConditionalCapabilityINTEL => struct { condition: Id, capability: Capability }, + .OpSpecConstantTargetINTEL => struct { id_result_type: Id, id_result: Id, target: LiteralInteger, features: []const LiteralInteger = &.{} }, + .OpSpecConstantArchitectureINTEL => struct { id_result_type: Id, id_result: Id, category: LiteralInteger, family: LiteralInteger, opcode: LiteralInteger, architecture: LiteralInteger }, + .OpSpecConstantCapabilitiesINTEL => struct { id_result_type: Id, id_result: Id, capabilities: []const Capability = &.{} }, + .OpConditionalCopyObjectINTEL => struct { id_result_type: Id, id_result: Id, id_ref: []const Id = &.{} }, .OpGroupIMulKHR => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, x: Id }, .OpGroupFMulKHR => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, x: Id }, .OpGroupBitwiseAndKHR => struct { id_result_type: Id, id_result: Id, execution: Id, operation: GroupOperation, x: Id }, @@ -3074,6 +3102,7 @@ pub const Opcode = enum(u16) { .OpGroupNonUniformRotateKHR => .group, .OpSubgroupReadInvocationKHR => .group, .OpExtInstWithForwardRefsKHR => .extension, + .OpUntypedGroupAsyncCopyKHR => .group, .OpTraceRayKHR => .reserved, .OpExecuteCallableKHR => .reserved, .OpConvertUToAccelerationStructureKHR => .reserved, @@ -3104,10 +3133,14 @@ pub const Opcode = enum(u16) { .OpImageBoxFilterQCOM => .image, .OpImageBlockMatchSSDQCOM => .image, .OpImageBlockMatchSADQCOM => .image, + .OpBitCastArrayQCOM => .conversion, .OpImageBlockMatchWindowSSDQCOM => .image, .OpImageBlockMatchWindowSADQCOM => .image, .OpImageBlockMatchGatherSSDQCOM => .image, .OpImageBlockMatchGatherSADQCOM => .image, + .OpCompositeConstructCoopMatQCOM => .composite, + .OpCompositeExtractCoopMatQCOM => .composite, + .OpExtractSubArrayQCOM => .composite, .OpGroupIAddNonUniformAMD => .group, .OpGroupFAddNonUniformAMD => .group, .OpGroupFMinNonUniformAMD => .group, @@ -3310,6 +3343,13 @@ pub const Opcode = enum(u16) { .OpSubgroup2DBlockStoreINTEL => .group, .OpSubgroupMatrixMultiplyAccumulateINTEL => .group, .OpBitwiseFunctionINTEL => .bit, + .OpConditionalExtensionINTEL => .extension, + .OpConditionalEntryPointINTEL => .mode_setting, + .OpConditionalCapabilityINTEL => .mode_setting, + .OpSpecConstantTargetINTEL => .constant_creation, + .OpSpecConstantArchitectureINTEL => .constant_creation, + .OpSpecConstantCapabilitiesINTEL => .constant_creation, + .OpConditionalCopyObjectINTEL => .composite, .OpGroupIMulKHR => .group, .OpGroupFMulKHR => .group, .OpGroupBitwiseAndKHR => .group, @@ -4647,6 +4687,7 @@ pub const Decoration = enum(u32) { host_access_intel = 6188, init_mode_intel = 6190, implement_in_register_map_intel = 6191, + conditional_intel = 6247, cache_control_load_intel = 6442, cache_control_store_intel = 6443, @@ -4792,6 +4833,7 @@ pub const Decoration = enum(u32) { host_access_intel: struct { access: HostAccessQualifier, name: LiteralString }, init_mode_intel: struct { trigger: InitializationModeQualifier }, implement_in_register_map_intel: struct { value: LiteralInteger }, + conditional_intel: struct { condition: Id }, cache_control_load_intel: struct { cache_level: LiteralInteger, cache_control: LoadCacheControl }, cache_control_store_intel: struct { cache_level: LiteralInteger, cache_control: StoreCacheControl }, }; @@ -5063,6 +5105,7 @@ pub const Capability = enum(u32) { texture_box_filter_qcom = 4485, texture_block_match_qcom = 4486, tile_shading_qcom = 4495, + cooperative_matrix_conversion_qcom = 4496, texture_block_match2qcom = 4498, float16image_amd = 5008, image_gather_bias_lod_amd = 5009, @@ -5212,12 +5255,1050 @@ pub const Capability = enum(u32) { subgroup2d_block_transpose_intel = 6230, subgroup_matrix_multiply_accumulate_intel = 6236, ternary_bitwise_function_intel = 6241, + spec_conditional_intel = 6245, + function_variants_intel = 6246, group_uniform_arithmetic_khr = 6400, tensor_float32rounding_intel = 6425, masked_gather_scatter_intel = 6427, cache_controls_intel = 6441, register_limits_intel = 6460, bindless_images_intel = 6528, + + pub fn dependencies(self: Capability) []const Extension { + return switch (self) { + .matrix => &.{ + .v1_0, + }, + .shader => &.{ + .v1_0, + }, + .geometry => &.{ + .v1_0, + }, + .tessellation => &.{ + .v1_0, + }, + .addresses => &.{ + .v1_0, + }, + .linkage => &.{ + .v1_0, + }, + .kernel => &.{ + .v1_0, + }, + .vector16 => &.{ + .v1_0, + }, + .float16buffer => &.{ + .v1_0, + }, + .float16 => &.{ + .v1_0, + }, + .float64 => &.{ + .v1_0, + }, + .int64 => &.{ + .v1_0, + }, + .int64atomics => &.{ + .v1_0, + }, + .image_basic => &.{ + .v1_0, + }, + .image_read_write => &.{ + .v1_0, + }, + .image_mipmap => &.{ + .v1_0, + }, + .pipes => &.{ + .v1_0, + }, + .groups => &.{ + .v1_0, + .SPV_AMD_shader_ballot, + }, + .device_enqueue => &.{ + .v1_0, + }, + .literal_sampler => &.{ + .v1_0, + }, + .atomic_storage => &.{ + .v1_0, + }, + .int16 => &.{ + .v1_0, + }, + .tessellation_point_size => &.{ + .v1_0, + }, + .geometry_point_size => &.{ + .v1_0, + }, + .image_gather_extended => &.{ + .v1_0, + }, + .storage_image_multisample => &.{ + .v1_0, + }, + .uniform_buffer_array_dynamic_indexing => &.{ + .v1_0, + }, + .sampled_image_array_dynamic_indexing => &.{ + .v1_0, + }, + .storage_buffer_array_dynamic_indexing => &.{ + .v1_0, + }, + .storage_image_array_dynamic_indexing => &.{ + .v1_0, + }, + .clip_distance => &.{ + .v1_0, + }, + .cull_distance => &.{ + .v1_0, + }, + .image_cube_array => &.{ + .v1_0, + }, + .sample_rate_shading => &.{ + .v1_0, + }, + .image_rect => &.{ + .v1_0, + }, + .sampled_rect => &.{ + .v1_0, + }, + .generic_pointer => &.{ + .v1_0, + }, + .int8 => &.{ + .v1_0, + }, + .input_attachment => &.{ + .v1_0, + }, + .sparse_residency => &.{ + .v1_0, + }, + .min_lod => &.{ + .v1_0, + }, + .sampled1d => &.{ + .v1_0, + }, + .image1d => &.{ + .v1_0, + }, + .sampled_cube_array => &.{ + .v1_0, + }, + .sampled_buffer => &.{ + .v1_0, + }, + .image_buffer => &.{ + .v1_0, + }, + .image_ms_array => &.{ + .v1_0, + }, + .storage_image_extended_formats => &.{ + .v1_0, + }, + .image_query => &.{ + .v1_0, + }, + .derivative_control => &.{ + .v1_0, + }, + .interpolation_function => &.{ + .v1_0, + }, + .transform_feedback => &.{ + .v1_0, + }, + .geometry_streams => &.{ + .v1_0, + }, + .storage_image_read_without_format => &.{ + .v1_0, + }, + .storage_image_write_without_format => &.{ + .v1_0, + }, + .multi_viewport => &.{ + .v1_0, + }, + .subgroup_dispatch => &.{ + .v1_1, + }, + .named_barrier => &.{ + .v1_1, + }, + .pipe_storage => &.{ + .v1_1, + }, + .group_non_uniform => &.{ + .v1_3, + }, + .group_non_uniform_vote => &.{ + .v1_3, + }, + .group_non_uniform_arithmetic => &.{ + .v1_3, + }, + .group_non_uniform_ballot => &.{ + .v1_3, + }, + .group_non_uniform_shuffle => &.{ + .v1_3, + }, + .group_non_uniform_shuffle_relative => &.{ + .v1_3, + }, + .group_non_uniform_clustered => &.{ + .v1_3, + }, + .group_non_uniform_quad => &.{ + .v1_3, + }, + .shader_layer => &.{ + .v1_5, + }, + .shader_viewport_index => &.{ + .v1_5, + }, + .uniform_decoration => &.{ + .v1_6, + }, + .core_builtins_arm => &.{ + .v1_0, + .SPV_ARM_core_builtins, + }, + .tile_image_color_read_access_ext => &.{ + .v1_0, + .SPV_EXT_shader_tile_image, + }, + .tile_image_depth_read_access_ext => &.{ + .v1_0, + .SPV_EXT_shader_tile_image, + }, + .tile_image_stencil_read_access_ext => &.{ + .v1_0, + .SPV_EXT_shader_tile_image, + }, + .tensors_arm => &.{ + .v1_0, + .SPV_ARM_tensors, + }, + .storage_tensor_array_dynamic_indexing_arm => &.{ + .v1_0, + .SPV_ARM_tensors, + }, + .storage_tensor_array_non_uniform_indexing_arm => &.{ + .v1_0, + .SPV_ARM_tensors, + }, + .graph_arm => &.{ + .v1_0, + .SPV_ARM_graph, + }, + .cooperative_matrix_layouts_arm => &.{ + .v1_0, + .SPV_ARM_cooperative_matrix_layouts, + }, + .float8ext => &.{ + .v1_0, + .SPV_EXT_float8, + }, + .float8cooperative_matrix_ext => &.{ + .v1_0, + .SPV_EXT_float8, + }, + .fragment_shading_rate_khr => &.{ + .v1_0, + .SPV_KHR_fragment_shading_rate, + }, + .subgroup_ballot_khr => &.{ + .v1_0, + .SPV_KHR_shader_ballot, + }, + .draw_parameters => &.{ + .v1_3, + .SPV_KHR_shader_draw_parameters, + }, + .workgroup_memory_explicit_layout_khr => &.{ + .v1_0, + .SPV_KHR_workgroup_memory_explicit_layout, + }, + .workgroup_memory_explicit_layout8bit_access_khr => &.{ + .v1_0, + .SPV_KHR_workgroup_memory_explicit_layout, + }, + .workgroup_memory_explicit_layout16bit_access_khr => &.{ + .v1_0, + .SPV_KHR_workgroup_memory_explicit_layout, + }, + .subgroup_vote_khr => &.{ + .v1_0, + .SPV_KHR_subgroup_vote, + }, + .storage_buffer16bit_access => &.{ + .v1_3, + .SPV_KHR_16bit_storage, + }, + .uniform_and_storage_buffer16bit_access => &.{ + .v1_3, + .SPV_KHR_16bit_storage, + }, + .storage_push_constant16 => &.{ + .v1_3, + .SPV_KHR_16bit_storage, + }, + .storage_input_output16 => &.{ + .v1_3, + .SPV_KHR_16bit_storage, + }, + .device_group => &.{ + .v1_3, + .SPV_KHR_device_group, + }, + .multi_view => &.{ + .v1_3, + .SPV_KHR_multiview, + }, + .variable_pointers_storage_buffer => &.{ + .v1_3, + .SPV_KHR_variable_pointers, + }, + .variable_pointers => &.{ + .v1_3, + .SPV_KHR_variable_pointers, + }, + .atomic_storage_ops => &.{ + .v1_0, + .SPV_KHR_shader_atomic_counter_ops, + }, + .sample_mask_post_depth_coverage => &.{ + .v1_0, + .SPV_KHR_post_depth_coverage, + }, + .storage_buffer8bit_access => &.{ + .v1_5, + .SPV_KHR_8bit_storage, + }, + .uniform_and_storage_buffer8bit_access => &.{ + .v1_5, + .SPV_KHR_8bit_storage, + }, + .storage_push_constant8 => &.{ + .v1_5, + .SPV_KHR_8bit_storage, + }, + .denorm_preserve => &.{ + .v1_4, + .SPV_KHR_float_controls, + }, + .denorm_flush_to_zero => &.{ + .v1_4, + .SPV_KHR_float_controls, + }, + .signed_zero_inf_nan_preserve => &.{ + .v1_4, + .SPV_KHR_float_controls, + }, + .rounding_mode_rte => &.{ + .v1_4, + .SPV_KHR_float_controls, + }, + .rounding_mode_rtz => &.{ + .v1_4, + .SPV_KHR_float_controls, + }, + .ray_query_provisional_khr => &.{ + .v1_0, + .SPV_KHR_ray_query, + }, + .ray_query_khr => &.{ + .v1_0, + .SPV_KHR_ray_query, + }, + .untyped_pointers_khr => &.{ + .v1_0, + .SPV_KHR_untyped_pointers, + }, + .ray_traversal_primitive_culling_khr => &.{ + .v1_0, + .SPV_KHR_ray_query, + .SPV_KHR_ray_tracing, + }, + .ray_tracing_khr => &.{ + .v1_0, + .SPV_KHR_ray_tracing, + }, + .texture_sample_weighted_qcom => &.{ + .v1_0, + .SPV_QCOM_image_processing, + }, + .texture_box_filter_qcom => &.{ + .v1_0, + .SPV_QCOM_image_processing, + }, + .texture_block_match_qcom => &.{ + .v1_0, + .SPV_QCOM_image_processing, + }, + .tile_shading_qcom => &.{ + .v1_0, + .SPV_QCOM_tile_shading, + }, + .cooperative_matrix_conversion_qcom => &.{ + .v1_0, + .SPV_QCOM_cooperative_matrix_conversion, + }, + .texture_block_match2qcom => &.{ + .v1_0, + .SPV_QCOM_image_processing2, + }, + .float16image_amd => &.{ + .v1_0, + .SPV_AMD_gpu_shader_half_float_fetch, + }, + .image_gather_bias_lod_amd => &.{ + .v1_0, + .SPV_AMD_texture_gather_bias_lod, + }, + .fragment_mask_amd => &.{ + .v1_0, + .SPV_AMD_shader_fragment_mask, + }, + .stencil_export_ext => &.{ + .v1_0, + .SPV_EXT_shader_stencil_export, + }, + .image_read_write_lod_amd => &.{ + .v1_0, + .SPV_AMD_shader_image_load_store_lod, + }, + .int64image_ext => &.{ + .v1_0, + .SPV_EXT_shader_image_int64, + }, + .shader_clock_khr => &.{ + .v1_0, + .SPV_KHR_shader_clock, + }, + .shader_enqueue_amdx => &.{ + .v1_0, + .SPV_AMDX_shader_enqueue, + }, + .quad_control_khr => &.{ + .v1_0, + .SPV_KHR_quad_control, + }, + .int4type_intel => &.{ + .v1_0, + .SPV_INTEL_int4, + }, + .int4cooperative_matrix_intel => &.{ + .v1_0, + .SPV_INTEL_int4, + }, + .b_float16type_khr => &.{ + .v1_0, + .SPV_KHR_bfloat16, + }, + .b_float16dot_product_khr => &.{ + .v1_0, + .SPV_KHR_bfloat16, + }, + .b_float16cooperative_matrix_khr => &.{ + .v1_0, + .SPV_KHR_bfloat16, + }, + .sample_mask_override_coverage_nv => &.{ + .v1_0, + .SPV_NV_sample_mask_override_coverage, + }, + .geometry_shader_passthrough_nv => &.{ + .v1_0, + .SPV_NV_geometry_shader_passthrough, + }, + .shader_viewport_index_layer_ext => &.{ + .v1_0, + .SPV_EXT_shader_viewport_index_layer, + .SPV_NV_viewport_array2, + }, + .shader_viewport_mask_nv => &.{ + .v1_0, + .SPV_NV_viewport_array2, + }, + .shader_stereo_view_nv => &.{ + .v1_0, + .SPV_NV_stereo_view_rendering, + }, + .per_view_attributes_nv => &.{ + .v1_0, + .SPV_NVX_multiview_per_view_attributes, + }, + .fragment_fully_covered_ext => &.{ + .v1_0, + .SPV_EXT_fragment_fully_covered, + }, + .mesh_shading_nv => &.{ + .v1_0, + .SPV_NV_mesh_shader, + }, + .image_footprint_nv => &.{ + .v1_0, + .SPV_NV_shader_image_footprint, + }, + .mesh_shading_ext => &.{ + .v1_0, + .SPV_EXT_mesh_shader, + }, + .fragment_barycentric_khr => &.{ + .v1_0, + .SPV_NV_fragment_shader_barycentric, + .SPV_KHR_fragment_shader_barycentric, + }, + .compute_derivative_group_quads_khr => &.{ + .v1_0, + .SPV_NV_compute_shader_derivatives, + .SPV_KHR_compute_shader_derivatives, + }, + .fragment_density_ext => &.{ + .v1_0, + .SPV_EXT_fragment_invocation_density, + .SPV_NV_shading_rate, + }, + .group_non_uniform_partitioned_nv => &.{ + .v1_0, + .SPV_NV_shader_subgroup_partitioned, + }, + .shader_non_uniform => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .runtime_descriptor_array => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .input_attachment_array_dynamic_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .uniform_texel_buffer_array_dynamic_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .storage_texel_buffer_array_dynamic_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .uniform_buffer_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .sampled_image_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .storage_buffer_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .storage_image_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .input_attachment_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .uniform_texel_buffer_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .storage_texel_buffer_array_non_uniform_indexing => &.{ + .v1_5, + .SPV_EXT_descriptor_indexing, + }, + .ray_tracing_position_fetch_khr => &.{ + .v1_0, + .SPV_KHR_ray_tracing_position_fetch, + }, + .ray_tracing_nv => &.{ + .v1_0, + .SPV_NV_ray_tracing, + }, + .ray_tracing_motion_blur_nv => &.{ + .v1_0, + .SPV_NV_ray_tracing_motion_blur, + }, + .vulkan_memory_model => &.{ + .v1_5, + .SPV_KHR_vulkan_memory_model, + }, + .vulkan_memory_model_device_scope => &.{ + .v1_5, + .SPV_KHR_vulkan_memory_model, + }, + .physical_storage_buffer_addresses => &.{ + .v1_5, + .SPV_EXT_physical_storage_buffer, + .SPV_KHR_physical_storage_buffer, + }, + .compute_derivative_group_linear_khr => &.{ + .v1_0, + .SPV_NV_compute_shader_derivatives, + .SPV_KHR_compute_shader_derivatives, + }, + .ray_tracing_provisional_khr => &.{ + .v1_0, + .SPV_KHR_ray_tracing, + }, + .cooperative_matrix_nv => &.{ + .v1_0, + .SPV_NV_cooperative_matrix, + }, + .fragment_shader_sample_interlock_ext => &.{ + .v1_0, + .SPV_EXT_fragment_shader_interlock, + }, + .fragment_shader_shading_rate_interlock_ext => &.{ + .v1_0, + .SPV_EXT_fragment_shader_interlock, + }, + .shader_sm_builtins_nv => &.{ + .v1_0, + .SPV_NV_shader_sm_builtins, + }, + .fragment_shader_pixel_interlock_ext => &.{ + .v1_0, + .SPV_EXT_fragment_shader_interlock, + }, + .demote_to_helper_invocation => &.{ + .v1_6, + .SPV_EXT_demote_to_helper_invocation, + }, + .displacement_micromap_nv => &.{ + .v1_0, + .SPV_NV_displacement_micromap, + }, + .ray_tracing_opacity_micromap_ext => &.{ + .v1_0, + .SPV_EXT_opacity_micromap, + }, + .shader_invocation_reorder_nv => &.{ + .v1_0, + .SPV_NV_shader_invocation_reorder, + }, + .bindless_texture_nv => &.{ + .v1_0, + .SPV_NV_bindless_texture, + }, + .ray_query_position_fetch_khr => &.{ + .v1_0, + .SPV_KHR_ray_tracing_position_fetch, + }, + .cooperative_vector_nv => &.{ + .v1_0, + .SPV_NV_cooperative_vector, + }, + .atomic_float16vector_nv => &.{ + .v1_0, + .SPV_NV_shader_atomic_fp16_vector, + }, + .ray_tracing_displacement_micromap_nv => &.{ + .v1_0, + .SPV_NV_displacement_micromap, + }, + .raw_access_chains_nv => &.{ + .v1_0, + .SPV_NV_raw_access_chains, + }, + .ray_tracing_spheres_geometry_nv => &.{ + .v1_0, + .SPV_NV_linear_swept_spheres, + }, + .ray_tracing_linear_swept_spheres_geometry_nv => &.{ + .v1_0, + .SPV_NV_linear_swept_spheres, + }, + .cooperative_matrix_reductions_nv => &.{ + .v1_0, + .SPV_NV_cooperative_matrix2, + }, + .cooperative_matrix_conversions_nv => &.{ + .v1_0, + .SPV_NV_cooperative_matrix2, + }, + .cooperative_matrix_per_element_operations_nv => &.{ + .v1_0, + .SPV_NV_cooperative_matrix2, + }, + .cooperative_matrix_tensor_addressing_nv => &.{ + .v1_0, + .SPV_NV_cooperative_matrix2, + }, + .cooperative_matrix_block_loads_nv => &.{ + .v1_0, + .SPV_NV_cooperative_matrix2, + }, + .cooperative_vector_training_nv => &.{ + .v1_0, + .SPV_NV_cooperative_vector, + }, + .ray_tracing_cluster_acceleration_structure_nv => &.{ + .v1_0, + .SPV_NV_cluster_acceleration_structure, + }, + .tensor_addressing_nv => &.{ + .v1_0, + .SPV_NV_tensor_addressing, + }, + .subgroup_shuffle_intel => &.{ + .v1_0, + .SPV_INTEL_subgroups, + }, + .subgroup_buffer_block_iointel => &.{ + .v1_0, + .SPV_INTEL_subgroups, + }, + .subgroup_image_block_iointel => &.{ + .v1_0, + .SPV_INTEL_subgroups, + }, + .subgroup_image_media_block_iointel => &.{ + .v1_0, + .SPV_INTEL_media_block_io, + }, + .round_to_infinity_intel => &.{ + .v1_0, + .SPV_INTEL_float_controls2, + }, + .floating_point_mode_intel => &.{ + .v1_0, + .SPV_INTEL_float_controls2, + }, + .integer_functions2intel => &.{ + .v1_0, + .SPV_INTEL_shader_integer_functions2, + }, + .function_pointers_intel => &.{ + .v1_0, + .SPV_INTEL_function_pointers, + }, + .indirect_references_intel => &.{ + .v1_0, + .SPV_INTEL_function_pointers, + }, + .asm_intel => &.{ + .v1_0, + .SPV_INTEL_inline_assembly, + }, + .atomic_float32min_max_ext => &.{ + .v1_0, + .SPV_EXT_shader_atomic_float_min_max, + }, + .atomic_float64min_max_ext => &.{ + .v1_0, + .SPV_EXT_shader_atomic_float_min_max, + }, + .atomic_float16min_max_ext => &.{ + .v1_0, + .SPV_EXT_shader_atomic_float_min_max, + }, + .vector_compute_intel => &.{ + .v1_0, + .SPV_INTEL_vector_compute, + }, + .vector_any_intel => &.{ + .v1_0, + .SPV_INTEL_vector_compute, + }, + .expect_assume_khr => &.{ + .v1_0, + .SPV_KHR_expect_assume, + }, + .subgroup_avc_motion_estimation_intel => &.{ + .v1_0, + .SPV_INTEL_device_side_avc_motion_estimation, + }, + .subgroup_avc_motion_estimation_intra_intel => &.{ + .v1_0, + .SPV_INTEL_device_side_avc_motion_estimation, + }, + .subgroup_avc_motion_estimation_chroma_intel => &.{ + .v1_0, + .SPV_INTEL_device_side_avc_motion_estimation, + }, + .variable_length_array_intel => &.{ + .v1_0, + .SPV_INTEL_variable_length_array, + }, + .function_float_control_intel => &.{ + .v1_0, + .SPV_INTEL_float_controls2, + }, + .fpga_memory_attributes_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_memory_attributes, + }, + .fp_fast_math_mode_intel => &.{ + .v1_0, + .SPV_INTEL_fp_fast_math_mode, + }, + .arbitrary_precision_integers_intel => &.{ + .v1_0, + .SPV_INTEL_arbitrary_precision_integers, + }, + .arbitrary_precision_floating_point_intel => &.{ + .v1_0, + .SPV_INTEL_arbitrary_precision_floating_point, + }, + .unstructured_loop_controls_intel => &.{ + .v1_0, + .SPV_INTEL_unstructured_loop_controls, + }, + .fpga_loop_controls_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_loop_controls, + }, + .kernel_attributes_intel => &.{ + .v1_0, + .SPV_INTEL_kernel_attributes, + }, + .fpga_kernel_attributes_intel => &.{ + .v1_0, + .SPV_INTEL_kernel_attributes, + }, + .fpga_memory_accesses_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_memory_accesses, + }, + .fpga_cluster_attributes_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_cluster_attributes, + }, + .loop_fuse_intel => &.{ + .v1_0, + .SPV_INTEL_loop_fuse, + }, + .fpgadsp_control_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_dsp_control, + }, + .memory_access_aliasing_intel => &.{ + .v1_0, + .SPV_INTEL_memory_access_aliasing, + }, + .fpga_invocation_pipelining_attributes_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_invocation_pipelining_attributes, + }, + .fpga_buffer_location_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_buffer_location, + }, + .arbitrary_precision_fixed_point_intel => &.{ + .v1_0, + .SPV_INTEL_arbitrary_precision_fixed_point, + }, + .usm_storage_classes_intel => &.{ + .v1_0, + .SPV_INTEL_usm_storage_classes, + }, + .runtime_aligned_attribute_intel => &.{ + .v1_0, + .SPV_INTEL_runtime_aligned, + }, + .io_pipes_intel => &.{ + .v1_0, + .SPV_INTEL_io_pipes, + }, + .blocking_pipes_intel => &.{ + .v1_0, + .SPV_INTEL_blocking_pipes, + }, + .fpga_reg_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_reg, + }, + .dot_product_input_all => &.{ + .v1_6, + .SPV_KHR_integer_dot_product, + }, + .dot_product_input4x8bit => &.{ + .v1_6, + .SPV_KHR_integer_dot_product, + }, + .dot_product_input4x8bit_packed => &.{ + .v1_6, + .SPV_KHR_integer_dot_product, + }, + .dot_product => &.{ + .v1_6, + .SPV_KHR_integer_dot_product, + }, + .ray_cull_mask_khr => &.{ + .v1_0, + .SPV_KHR_ray_cull_mask, + }, + .cooperative_matrix_khr => &.{ + .v1_0, + .SPV_KHR_cooperative_matrix, + }, + .replicated_composites_ext => &.{ + .v1_0, + .SPV_EXT_replicated_composites, + }, + .bit_instructions => &.{ + .v1_0, + .SPV_KHR_bit_instructions, + }, + .group_non_uniform_rotate_khr => &.{ + .v1_0, + .SPV_KHR_subgroup_rotate, + }, + .float_controls2 => &.{ + .v1_0, + .SPV_KHR_float_controls2, + }, + .atomic_float32add_ext => &.{ + .v1_0, + .SPV_EXT_shader_atomic_float_add, + }, + .atomic_float64add_ext => &.{ + .v1_0, + .SPV_EXT_shader_atomic_float_add, + }, + .long_composites_intel => &.{ + .v1_0, + .SPV_INTEL_long_composites, + }, + .opt_none_ext => &.{ + .v1_0, + .SPV_EXT_optnone, + .SPV_INTEL_optnone, + }, + .atomic_float16add_ext => &.{ + .v1_0, + .SPV_EXT_shader_atomic_float16_add, + }, + .debug_info_module_intel => &.{ + .v1_0, + .SPV_INTEL_debug_module, + }, + .b_float16conversion_intel => &.{ + .v1_0, + .SPV_INTEL_bfloat16_conversion, + }, + .split_barrier_intel => &.{ + .v1_0, + .SPV_INTEL_split_barrier, + }, + .arithmetic_fence_ext => &.{ + .v1_0, + .SPV_EXT_arithmetic_fence, + }, + .fpga_cluster_attributes_v2intel => &.{ + .v1_0, + .SPV_INTEL_fpga_cluster_attributes, + }, + .fpga_kernel_attributesv2intel => &.{ + .v1_0, + .SPV_INTEL_kernel_attributes, + }, + .task_sequence_intel => &.{ + .v1_0, + .SPV_INTEL_task_sequence, + }, + .fp_max_error_intel => &.{ + .v1_0, + .SPV_INTEL_fp_max_error, + }, + .fpga_latency_control_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_latency_control, + }, + .fpga_argument_interfaces_intel => &.{ + .v1_0, + .SPV_INTEL_fpga_argument_interfaces, + }, + .global_variable_host_access_intel => &.{ + .v1_0, + .SPV_INTEL_global_variable_host_access, + }, + .global_variable_fpga_decorations_intel => &.{ + .v1_0, + .SPV_INTEL_global_variable_fpga_decorations, + }, + .subgroup_buffer_prefetch_intel => &.{ + .v1_0, + .SPV_INTEL_subgroup_buffer_prefetch, + }, + .subgroup2d_block_iointel => &.{ + .v1_0, + .SPV_INTEL_2d_block_io, + }, + .subgroup2d_block_transform_intel => &.{ + .v1_0, + .SPV_INTEL_2d_block_io, + }, + .subgroup2d_block_transpose_intel => &.{ + .v1_0, + .SPV_INTEL_2d_block_io, + }, + .subgroup_matrix_multiply_accumulate_intel => &.{ + .v1_0, + .SPV_INTEL_subgroup_matrix_multiply_accumulate, + }, + .ternary_bitwise_function_intel => &.{ + .v1_0, + .SPV_INTEL_ternary_bitwise_function, + }, + .spec_conditional_intel => &.{ + .v1_0, + .SPV_INTEL_function_variants, + }, + .function_variants_intel => &.{ + .v1_0, + .SPV_INTEL_function_variants, + }, + .group_uniform_arithmetic_khr => &.{ + .v1_0, + .SPV_KHR_uniform_group_instructions, + }, + .tensor_float32rounding_intel => &.{ + .v1_0, + .SPV_INTEL_tensor_float32_conversion, + }, + .masked_gather_scatter_intel => &.{ + .v1_0, + .SPV_INTEL_masked_gather_scatter, + }, + .cache_controls_intel => &.{ + .v1_0, + .SPV_INTEL_cache_controls, + }, + .register_limits_intel => &.{ + .v1_0, + .SPV_INTEL_maximum_registers, + }, + .bindless_images_intel => &.{ + .v1_0, + .SPV_INTEL_bindless_images, + }, + }; + } }; pub const RayQueryIntersection = enum(u32) { ray_query_candidate_intersection_khr = 0, @@ -9238,6 +10319,23 @@ pub const InstructionSet = enum { .{ .kind = .id_ref, .quantifier = .variadic }, }, }, + .{ + .name = "OpUntypedGroupAsyncCopyKHR", + .opcode = 4434, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .memory_access, .quantifier = .optional }, + .{ .kind = .memory_access, .quantifier = .optional }, + }, + }, .{ .name = "OpTraceRayKHR", .opcode = 4445, @@ -9544,6 +10642,15 @@ pub const InstructionSet = enum { .{ .kind = .id_ref, .quantifier = .required }, }, }, + .{ + .name = "OpBitCastArrayQCOM", + .opcode = 4497, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + }, + }, .{ .name = "OpImageBlockMatchWindowSSDQCOM", .opcode = 4500, @@ -9596,6 +10703,34 @@ pub const InstructionSet = enum { .{ .kind = .id_ref, .quantifier = .required }, }, }, + .{ + .name = "OpCompositeConstructCoopMatQCOM", + .opcode = 4540, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + }, + }, + .{ + .name = "OpCompositeExtractCoopMatQCOM", + .opcode = 4541, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + }, + }, + .{ + .name = "OpExtractSubArrayQCOM", + .opcode = 4542, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + }, + }, .{ .name = "OpGroupIAddNonUniformAMD", .opcode = 5000, @@ -13663,6 +14798,73 @@ pub const InstructionSet = enum { .{ .kind = .id_ref, .quantifier = .required }, }, }, + .{ + .name = "OpConditionalExtensionINTEL", + .opcode = 6248, + .operands = &.{ + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .literal_string, .quantifier = .required }, + }, + }, + .{ + .name = "OpConditionalEntryPointINTEL", + .opcode = 6249, + .operands = &.{ + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .execution_model, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .literal_string, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpConditionalCapabilityINTEL", + .opcode = 6250, + .operands = &.{ + .{ .kind = .id_ref, .quantifier = .required }, + .{ .kind = .capability, .quantifier = .required }, + }, + }, + .{ + .name = "OpSpecConstantTargetINTEL", + .opcode = 6251, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .literal_integer, .quantifier = .required }, + .{ .kind = .literal_integer, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpSpecConstantArchitectureINTEL", + .opcode = 6252, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .literal_integer, .quantifier = .required }, + .{ .kind = .literal_integer, .quantifier = .required }, + .{ .kind = .literal_integer, .quantifier = .required }, + .{ .kind = .literal_integer, .quantifier = .required }, + }, + }, + .{ + .name = "OpSpecConstantCapabilitiesINTEL", + .opcode = 6253, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .capability, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpConditionalCopyObjectINTEL", + .opcode = 6254, + .operands = &.{ + .{ .kind = .id_result_type, .quantifier = .required }, + .{ .kind = .id_result, .quantifier = .required }, + .{ .kind = .id_ref, .quantifier = .variadic }, + }, + }, .{ .name = "OpGroupIMulKHR", .opcode = 6401, @@ -15680,3 +16882,153 @@ pub const InstructionSet = enum { }; } }; +pub const Extension = enum { + v1_0, + v1_1, + v1_2, + v1_3, + v1_4, + v1_5, + v1_6, + SPV_AMD_shader_ballot, + SPV_ARM_core_builtins, + SPV_EXT_shader_tile_image, + SPV_ARM_tensors, + SPV_ARM_graph, + SPV_ARM_cooperative_matrix_layouts, + SPV_EXT_float8, + SPV_KHR_fragment_shading_rate, + SPV_KHR_shader_ballot, + SPV_KHR_shader_draw_parameters, + SPV_KHR_workgroup_memory_explicit_layout, + SPV_KHR_subgroup_vote, + SPV_KHR_16bit_storage, + SPV_KHR_device_group, + SPV_KHR_multiview, + SPV_KHR_variable_pointers, + SPV_KHR_shader_atomic_counter_ops, + SPV_KHR_post_depth_coverage, + SPV_KHR_8bit_storage, + SPV_KHR_float_controls, + SPV_KHR_ray_query, + SPV_KHR_untyped_pointers, + SPV_KHR_ray_tracing, + SPV_QCOM_image_processing, + SPV_QCOM_tile_shading, + SPV_QCOM_cooperative_matrix_conversion, + SPV_QCOM_image_processing2, + SPV_AMD_gpu_shader_half_float_fetch, + SPV_AMD_texture_gather_bias_lod, + SPV_AMD_shader_fragment_mask, + SPV_EXT_shader_stencil_export, + SPV_AMD_shader_image_load_store_lod, + SPV_EXT_shader_image_int64, + SPV_KHR_shader_clock, + SPV_AMDX_shader_enqueue, + SPV_KHR_quad_control, + SPV_INTEL_int4, + SPV_KHR_bfloat16, + SPV_NV_sample_mask_override_coverage, + SPV_NV_geometry_shader_passthrough, + SPV_EXT_shader_viewport_index_layer, + SPV_NV_viewport_array2, + SPV_NV_stereo_view_rendering, + SPV_NVX_multiview_per_view_attributes, + SPV_EXT_fragment_fully_covered, + SPV_NV_mesh_shader, + SPV_NV_shader_image_footprint, + SPV_EXT_mesh_shader, + SPV_NV_fragment_shader_barycentric, + SPV_KHR_fragment_shader_barycentric, + SPV_NV_compute_shader_derivatives, + SPV_KHR_compute_shader_derivatives, + SPV_EXT_fragment_invocation_density, + SPV_NV_shading_rate, + SPV_NV_shader_subgroup_partitioned, + SPV_EXT_descriptor_indexing, + SPV_KHR_ray_tracing_position_fetch, + SPV_NV_ray_tracing, + SPV_NV_ray_tracing_motion_blur, + SPV_KHR_vulkan_memory_model, + SPV_EXT_physical_storage_buffer, + SPV_KHR_physical_storage_buffer, + SPV_NV_cooperative_matrix, + SPV_EXT_fragment_shader_interlock, + SPV_NV_shader_sm_builtins, + SPV_EXT_demote_to_helper_invocation, + SPV_NV_displacement_micromap, + SPV_EXT_opacity_micromap, + SPV_NV_shader_invocation_reorder, + SPV_NV_bindless_texture, + SPV_NV_cooperative_vector, + SPV_NV_shader_atomic_fp16_vector, + SPV_NV_raw_access_chains, + SPV_NV_linear_swept_spheres, + SPV_NV_cooperative_matrix2, + SPV_NV_cluster_acceleration_structure, + SPV_NV_tensor_addressing, + SPV_INTEL_subgroups, + SPV_INTEL_media_block_io, + SPV_INTEL_float_controls2, + SPV_INTEL_shader_integer_functions2, + SPV_INTEL_function_pointers, + SPV_INTEL_inline_assembly, + SPV_EXT_shader_atomic_float_min_max, + SPV_INTEL_vector_compute, + SPV_KHR_expect_assume, + SPV_INTEL_device_side_avc_motion_estimation, + SPV_INTEL_variable_length_array, + SPV_INTEL_fpga_memory_attributes, + SPV_INTEL_fp_fast_math_mode, + SPV_INTEL_arbitrary_precision_integers, + SPV_INTEL_arbitrary_precision_floating_point, + SPV_INTEL_unstructured_loop_controls, + SPV_INTEL_fpga_loop_controls, + SPV_INTEL_kernel_attributes, + SPV_INTEL_fpga_memory_accesses, + SPV_INTEL_fpga_cluster_attributes, + SPV_INTEL_loop_fuse, + SPV_INTEL_fpga_dsp_control, + SPV_INTEL_memory_access_aliasing, + SPV_INTEL_fpga_invocation_pipelining_attributes, + SPV_INTEL_fpga_buffer_location, + SPV_INTEL_arbitrary_precision_fixed_point, + SPV_INTEL_usm_storage_classes, + SPV_INTEL_runtime_aligned, + SPV_INTEL_io_pipes, + SPV_INTEL_blocking_pipes, + SPV_INTEL_fpga_reg, + SPV_KHR_integer_dot_product, + SPV_KHR_ray_cull_mask, + SPV_KHR_cooperative_matrix, + SPV_EXT_replicated_composites, + SPV_KHR_bit_instructions, + SPV_KHR_subgroup_rotate, + SPV_KHR_float_controls2, + SPV_EXT_shader_atomic_float_add, + SPV_INTEL_long_composites, + SPV_EXT_optnone, + SPV_INTEL_optnone, + SPV_EXT_shader_atomic_float16_add, + SPV_INTEL_debug_module, + SPV_INTEL_bfloat16_conversion, + SPV_INTEL_split_barrier, + SPV_EXT_arithmetic_fence, + SPV_INTEL_task_sequence, + SPV_INTEL_fp_max_error, + SPV_INTEL_fpga_latency_control, + SPV_INTEL_fpga_argument_interfaces, + SPV_INTEL_global_variable_host_access, + SPV_INTEL_global_variable_fpga_decorations, + SPV_INTEL_subgroup_buffer_prefetch, + SPV_INTEL_2d_block_io, + SPV_INTEL_subgroup_matrix_multiply_accumulate, + SPV_INTEL_ternary_bitwise_function, + SPV_INTEL_function_variants, + SPV_KHR_uniform_group_instructions, + SPV_INTEL_tensor_float32_conversion, + SPV_INTEL_masked_gather_scatter, + SPV_INTEL_cache_controls, + SPV_INTEL_maximum_registers, + SPV_INTEL_bindless_images, +}; diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig index 7e28dc0a8b0b..43b4622b959f 100644 --- a/src/link/SpirV.zig +++ b/src/link/SpirV.zig @@ -189,35 +189,15 @@ pub fn updateExports( }, }; const nav_ty = ip.getNav(nav_index).typeOf(ip); - const target = zcu.getTarget(); if (ip.isFunctionType(nav_ty)) { const spv_decl_index = try linker.module.resolveNav(ip, nav_index); const cc = Type.fromInterned(nav_ty).fnCallingConvention(zcu); - const exec_model: spec.ExecutionModel = switch (target.os.tag) { - .vulkan, .opengl => switch (cc) { - .spirv_vertex => .vertex, - .spirv_fragment => .fragment, - .spirv_kernel => .gl_compute, - // TODO: We should integrate with the Linkage capability and export this function - .spirv_device => return, - else => unreachable, - }, - .opencl => switch (cc) { - .spirv_kernel => .kernel, - // TODO: We should integrate with the Linkage capability and export this function - .spirv_device => return, - else => unreachable, - }, - else => unreachable, - }; - for (export_indices) |export_idx| { const exp = export_idx.ptr(zcu); try linker.module.declareEntryPoint( spv_decl_index, exp.opts.name.toSlice(ip), - exec_model, - null, + cc, ); } } diff --git a/test/standalone/build.zig b/test/standalone/build.zig index cf08c9b18284..0474905d9b0c 100644 --- a/test/standalone/build.zig +++ b/test/standalone/build.zig @@ -29,6 +29,10 @@ pub fn build(b: *std.Build) void { const tools_tests_step = b.step("standalone_test_cases.tools", "Test tools"); step.dependOn(tools_tests_step); const tools_target = b.resolveTargetQuery(.{}); + const spirv_spec = b.createModule(.{ + .root_source_file = b.path("../../src/codegen/spirv/spec.zig"), + .target = tools_target, + }); for ([_][]const u8{ // Alphabetically sorted. No need to build `tools/spirv/grammar.zig`. "../../tools/dump-cov.zig", @@ -60,6 +64,9 @@ pub fn build(b: *std.Build) void { .target = tools_target, }), }); + if (std.mem.endsWith(u8, tool_src_path, "update_cpu_features.zig")) { + tool.root_module.addImport("spirv_spec", spirv_spec); + } tools_tests_step.dependOn(&tool.step); } for ([_][]const u8{ diff --git a/tools/gen_spirv_spec.zig b/tools/gen_spirv_spec.zig index c211d1022ea8..ae95fba0bacb 100644 --- a/tools/gen_spirv_spec.zig +++ b/tools/gen_spirv_spec.zig @@ -323,6 +323,38 @@ fn render( try renderOperandKinds(writer, all_operand_kinds.values(), extended_structs); try renderInstructionSet(writer, registry, extensions, all_operand_kinds); + try renderExtension(writer, all_operand_kinds.values()); +} + +fn renderExtension(writer: anytype, kinds: []const OperandKind) !void { + try writer.writeAll( + \\pub const Extension = enum { + \\v1_0, + \\v1_1, + \\v1_2, + \\v1_3, + \\v1_4, + \\v1_5, + \\v1_6, + \\ + ); + + var seen_extensions = std.StringHashMap(void).init(allocator); + defer seen_extensions.deinit(); + + for (kinds) |kind| { + if (std.mem.eql(u8, "Capability", kind.kind)) { + for (kind.enumerants.?) |enumerant| { + for (enumerant.extensions) |ext| { + if (seen_extensions.contains(ext)) continue; + try seen_extensions.put(ext, {}); + + try writer.print("{s},\n", .{ext}); + } + } + } + } + try writer.writeAll("};\n"); } fn renderInstructionSet( @@ -704,6 +736,39 @@ fn renderValueEnum( }); } + if (std.mem.eql(u8, "Capability", enumeration.kind)) { + try writer.writeAll( + \\ + \\pub fn dependencies(self: Capability) []const Extension { + \\ return switch (self) { + ); + + for (enum_indices) |i| { + const enumerant = enumerants[i]; + + // Convert version to enum. + // None is for reserved + // Example: "None" -> .v1_0 + // Example: "1.5" -> .v1_5 + const enum_version = enumerant.version.?; + const version: [4]u8 = .{ 'v', '1', '_', if (enum_version[0] == 'N') '0' else enum_version[2] }; + + try writer.print("\n.{f} => &.{{.{s},", .{ formatId(enumerant.enumerant), version }); + for (enumerant.extensions) |extension| { + try writer.print(".{s},", .{extension}); + } + try writer.writeAll("},"); + } + + try writer.writeAll( + \\}; + \\} + \\}; + \\ + ); + return; + } + if (!extended_structs.contains(enumeration.kind)) { try writer.writeAll("};\n"); return; diff --git a/tools/update_cpu_features.zig b/tools/update_cpu_features.zig index eeaa2bb39321..f068e73948ed 100644 --- a/tools/update_cpu_features.zig +++ b/tools/update_cpu_features.zig @@ -1,5 +1,6 @@ const std = @import("std"); const builtin = @import("builtin"); +const spirv_spec = @import("spirv_spec"); const fs = std.fs; const mem = std.mem; const json = std.json; @@ -1107,83 +1108,7 @@ const targets = [_]ArchTarget{ .td_name = "SPIRV", }, .branch_quota = 2000, - .extra_features = &.{ - .{ - .zig_name = "v1_0", - .desc = "Enable version 1.0", - .deps = &.{}, - }, - .{ - .zig_name = "v1_1", - .desc = "Enable version 1.1", - .deps = &.{"v1_0"}, - }, - .{ - .zig_name = "v1_2", - .desc = "Enable version 1.2", - .deps = &.{"v1_1"}, - }, - .{ - .zig_name = "v1_3", - .desc = "Enable version 1.3", - .deps = &.{"v1_2"}, - }, - .{ - .zig_name = "v1_4", - .desc = "Enable version 1.4", - .deps = &.{"v1_3"}, - }, - .{ - .zig_name = "v1_5", - .desc = "Enable version 1.5", - .deps = &.{"v1_4"}, - }, - .{ - .zig_name = "v1_6", - .desc = "Enable version 1.6", - .deps = &.{"v1_5"}, - }, - .{ - .zig_name = "int64", - .desc = "Enable Int64 capability", - .deps = &.{"v1_0"}, - }, - .{ - .zig_name = "float16", - .desc = "Enable Float16 capability", - .deps = &.{"v1_0"}, - }, - .{ - .zig_name = "float64", - .desc = "Enable Float64 capability", - .deps = &.{"v1_0"}, - }, - .{ - .zig_name = "storage_push_constant16", - .desc = "Enable SPV_KHR_16bit_storage extension and the StoragePushConstant16 capability", - .deps = &.{"v1_3"}, - }, - .{ - .zig_name = "arbitrary_precision_integers", - .desc = "Enable SPV_INTEL_arbitrary_precision_integers extension and the ArbitraryPrecisionIntegersINTEL capability", - .deps = &.{"v1_5"}, - }, - .{ - .zig_name = "generic_pointer", - .desc = "Enable GenericPointer capability", - .deps = &.{"v1_0"}, - }, - .{ - .zig_name = "vector16", - .desc = "Enable Vector16 capability", - .deps = &.{"v1_0"}, - }, - .{ - .zig_name = "variable_pointers", - .desc = "Enable SPV_KHR_physical_storage_buffer extension and the PhysicalStorageBufferAddresses capability", - .deps = &.{"v1_0"}, - }, - }, + .extra_features = spirvFeatures(), .extra_cpus = &.{ .{ .llvm_name = null, @@ -2179,6 +2104,41 @@ fn usageAndExit(arg0: []const u8, code: u8) noreturn { std.process.exit(code); } +fn spirvFeatures() []const Feature { + const cap_fields = @typeInfo(spirv_spec.Capability).@"enum".fields; + const ext_fields = @typeInfo(spirv_spec.Extension).@"enum".fields; + + var out_feature: [cap_fields.len + ext_fields.len]Feature = undefined; + + @setEvalBranchQuota(2000); + for (cap_fields, out_feature[0..cap_fields.len]) |field, *feature| { + feature.* = .{ + .zig_name = field.name, + .desc = "Enable " ++ field.name ++ " Capability.", + .deps = comptime res: { + const extensions = spirv_spec.Capability.dependencies(@enumFromInt(field.value)); + var out_extensions: [extensions.len][]const u8 = undefined; + for (extensions, 0..) |ext, i| { + out_extensions[i] = @tagName(ext); + } + const final_extensions = out_extensions; + break :res &final_extensions; + }, + }; + } + + for (ext_fields, out_feature[cap_fields.len..]) |field, *feature| { + feature.* = .{ + .zig_name = field.name, + .desc = "Enable " ++ field.name ++ " Extension.", + .deps = &.{}, + }; + } + + const final = out_feature; + return &final; +} + fn featureLessThan(_: void, a: Feature, b: Feature) bool { return std.ascii.lessThanIgnoreCase(a.zig_name, b.zig_name); }