rm cap checks: remove BuilderSpirv::has_capability

Author: Firestar99

crates/rustc_codegen_spirv/src/builder/builder_methods.rs

@@ -11,7 +11,7 @@ use crate::custom_insts::CustomInst;
 use crate::spirv_type::SpirvType;
 use itertools::Itertools;
 use rspirv::dr::{InsertPoint, Instruction, Operand};
-use rspirv::spirv::{Capability, MemoryModel, MemorySemantics, Op, Scope, StorageClass, Word};
+use rspirv::spirv::{MemoryModel, MemorySemantics, Op, Scope, StorageClass, Word};
 use rustc_abi::{Align, BackendRepr, Scalar, Size, WrappingRange};
 use rustc_apfloat::{Float, Round, Status, ieee};
 use rustc_codegen_ssa::MemFlags;
@@ -569,12 +569,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
     #[instrument(level = "trace", skip(self))]
     fn zombie_ptr_equal(&self, def: Word, inst: &str) {
-        if !self.builder.has_capability(Capability::VariablePointers) {
-            self.zombie(
-                def,
-                &format!("{inst} without OpCapability VariablePointers"),
-            );
-        }
+        self.zombie(
+            def,
+            &format!("{inst} without OpCapability VariablePointers"),
+        );
     }
 
     /// Convenience wrapper for `adjust_pointer_for_sized_access`, falling back

crates/rustc_codegen_spirv/src/builder/byte_addressable_buffer.rs

@@ -6,7 +6,6 @@ use crate::builder_spirv::{SpirvValue, SpirvValueExt, SpirvValueKind};
 use crate::spirv_type::SpirvType;
 use rspirv::spirv::{Decoration, Word};
 use rustc_abi::{Align, Size};
-use rustc_codegen_spirv_types::Capability;
 use rustc_codegen_ssa::traits::BuilderMethods;
 use rustc_errors::ErrorGuaranteed;
 use rustc_middle::ty::Ty;
@@ -50,13 +49,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .in_bounds_access_chain(u32_ptr, None, array, [actual_index])
             .unwrap()
             .with_type(u32_ptr);
-        if self.builder.has_capability(Capability::ShaderNonUniform) {
-            // apply NonUniform to the operation and the index
-            self.emit()
-                .decorate(ptr.def(self), Decoration::NonUniform, []);
-            self.emit()
-                .decorate(actual_index, Decoration::NonUniform, []);
-        }
+        // apply NonUniform to the operation and the index
+        self.emit()
+            .decorate(ptr.def(self), Decoration::NonUniform, []);
+        self.emit()
+            .decorate(actual_index, Decoration::NonUniform, []);
         self.load(u32_ty, ptr, Align::ONE)
     }
 
@@ -252,13 +249,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             .in_bounds_access_chain(u32_ptr, None, array, [actual_index])
             .unwrap()
             .with_type(u32_ptr);
-        if self.builder.has_capability(Capability::ShaderNonUniform) {
-            // apply NonUniform to the operation and the index
-            self.emit()
-                .decorate(ptr.def(self), Decoration::NonUniform, []);
-            self.emit()
-                .decorate(actual_index, Decoration::NonUniform, []);
-        }
+        // apply NonUniform to the operation and the index
+        self.emit()
+            .decorate(ptr.def(self), Decoration::NonUniform, []);
+        self.emit()
+            .decorate(actual_index, Decoration::NonUniform, []);
         self.store(value, ptr, Align::ONE);
         Ok(())
     }

crates/rustc_codegen_spirv/src/builder_spirv.rs

@@ -15,12 +15,11 @@ use rspirv::{binary::Assemble, binary::Disassemble};
 use rustc_abi::Size;
 use rustc_arena::DroplessArena;
 use rustc_codegen_ssa::traits::ConstCodegenMethods as _;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::ConstAllocation;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::source_map::SourceMap;
-use rustc_span::symbol::Symbol;
 use rustc_span::{DUMMY_SP, FileName, FileNameDisplayPreference, SourceFile, Span};
 use std::assert_matches::assert_matches;
 use std::cell::{RefCell, RefMut};
@@ -443,8 +442,6 @@ pub struct BuilderSpirv<'tcx> {
     id_to_const: RefCell<FxHashMap<Word, WithConstLegality<SpirvConst<'tcx, 'tcx>>>>,
 
     debug_file_cache: RefCell<FxHashMap<DebugFileKey, DebugFileSpirv<'tcx>>>,
-
-    enabled_capabilities: FxHashSet<Capability>,
 }
 
 impl<'tcx> BuilderSpirv<'tcx> {
@@ -461,50 +458,26 @@ impl<'tcx> BuilderSpirv<'tcx> {
         builder.set_version(version.0, version.1);
         builder.module_mut().header.as_mut().unwrap().generator = 0x001B_0000;
 
-        let mut enabled_capabilities = FxHashSet::default();
-
-        fn add_cap(
-            builder: &mut Builder,
-            enabled_capabilities: &mut FxHashSet<Capability>,
-            cap: Capability,
-        ) {
-            // This should be the only callsite of Builder::capability (aside from tests), to make
-            // sure the hashset stays in sync.
-            builder.capability(cap);
-            enabled_capabilities.insert(cap);
-        }
-        fn add_ext(builder: &mut Builder, ext: Symbol) {
-            // This should be the only callsite of Builder::extension (aside from tests), to make
-            // sure the hashset stays in sync.
-            builder.extension(ext.as_str());
-        }
-
         for feature in features {
             match *feature {
                 TargetFeature::Capability(cap) => {
-                    add_cap(&mut builder, &mut enabled_capabilities, cap);
+                    builder.capability(cap);
                 }
                 TargetFeature::Extension(ext) => {
-                    add_ext(&mut builder, ext);
+                    builder.extension(ext.as_str());
                 }
             }
         }
 
-        add_cap(&mut builder, &mut enabled_capabilities, Capability::Shader);
+        builder.capability(Capability::Shader);
         if memory_model == MemoryModel::Vulkan {
             if version < (1, 5) {
-                add_ext(&mut builder, sym.spv_khr_vulkan_memory_model);
+                builder.extension(sym.spv_khr_vulkan_memory_model.as_str());
             }
-            add_cap(
-                &mut builder,
-                &mut enabled_capabilities,
-                Capability::VulkanMemoryModel,
-            );
+            builder.capability(Capability::VulkanMemoryModel);
         }
-
         // The linker will always be ran on this module
-        add_cap(&mut builder, &mut enabled_capabilities, Capability::Linkage);
-
+        builder.capability(Capability::Linkage);
         builder.memory_model(AddressingModel::Logical, memory_model);
 
         Self {
@@ -514,7 +487,6 @@ impl<'tcx> BuilderSpirv<'tcx> {
             const_to_id: Default::default(),
             id_to_const: Default::default(),
             debug_file_cache: Default::default(),
-            enabled_capabilities,
         }
     }
 
@@ -535,10 +507,6 @@ impl<'tcx> BuilderSpirv<'tcx> {
             .unwrap();
     }
 
-    pub fn has_capability(&self, capability: Capability) -> bool {
-        self.enabled_capabilities.contains(&capability)
-    }
-
     /// See comment on `BuilderCursor`
     fn builder(&self, cursor: BuilderCursor) -> RefMut<'_, Builder> {
         let mut builder = self.builder.borrow_mut();

crates/rustc_codegen_spirv/src/codegen_cx/entry.rs

@@ -9,7 +9,7 @@ use crate::builder_spirv::{SpirvFunctionCursor, SpirvValue, SpirvValueExt};
 use crate::spirv_type::SpirvType;
 use rspirv::dr::Operand;
 use rspirv::spirv::{
-    BuiltIn, Capability, Decoration, Dim, ExecutionModel, FunctionControl, StorageClass, Word,
+    BuiltIn, Decoration, Dim, ExecutionModel, FunctionControl, StorageClass, Word,
 };
 use rustc_abi::FieldsShape;
 use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, MiscCodegenMethods as _};
@@ -931,16 +931,12 @@ impl<'tcx> CodegenCx<'tcx> {
             _ => false,
         };
         if let Some(attachment_index) = attrs.input_attachment_index {
-            if is_subpass_input && self.builder.has_capability(Capability::InputAttachment) {
+            if is_subpass_input {
                 self.emit_global().decorate(
                     var_id.unwrap(),
                     Decoration::InputAttachmentIndex,
                     std::iter::once(Operand::LiteralBit32(attachment_index.value)),
                 );
-            } else if is_subpass_input {
-                self.tcx
-                    .dcx()
-                    .span_err(hir_param.ty_span, "Missing capability InputAttachment");
             } else {
                 self.tcx.dcx().span_err(
                     attachment_index.span,