Support buffer resource arrays in IR, wgsl-in, and spv-out

src/back/spv/block.rs

@@ -196,9 +196,8 @@ impl<'w> BlockContext<'w> {
     fn is_intermediate(&self, expr_handle: Handle<crate::Expression>) -> bool {
         match self.ir_function.expressions[expr_handle] {
             crate::Expression::GlobalVariable(handle) => {
-                let ty = self.ir_module.global_variables[handle].ty;
-                match self.ir_module.types[ty].inner {
-                    crate::TypeInner::BindingArray { .. } => false,
+                match self.ir_module.global_variables[handle].space {
+                    crate::AddressSpace::Handle => false,
                     _ => true,
                 }
             }

src/back/spv/helpers.rs

@@ -102,7 +102,8 @@ pub fn global_needs_wrapper(ir_module: &crate::Module, var: &crate::GlobalVariab
             },
             None => false,
         },
-        // if it's not a structure, let's wrap it to be able to put "Block"
+        crate::TypeInner::BindingArray { .. } => false,
+        // if it's not a structure or a binding array, let's wrap it to be able to put "Block"
         _ => true,
     }
 }

src/back/spv/mod.rs

@@ -291,6 +291,7 @@ enum LocalType {
     PointerToBindingArray {
         base: Handle<crate::Type>,
         size: u64,
+        space: crate::AddressSpace,
     },
     BindingArray {
         base: Handle<crate::Type>,

src/back/spv/writer.rs

@@ -940,10 +940,11 @@ impl Writer {
                 let scalar_id = self.get_constant_scalar(crate::ScalarValue::Uint(size), 4);
                 Instruction::type_array(id, inner_ty, scalar_id)
             }
-            LocalType::PointerToBindingArray { base, size } => {
+            LocalType::PointerToBindingArray { base, size, space } => {
                 let inner_ty =
                     self.get_type_id(LookupType::Local(LocalType::BindingArray { base, size }));
-                Instruction::type_pointer(id, spirv::StorageClass::UniformConstant, inner_ty)
+                let class = map_storage_class(space);
+                Instruction::type_pointer(id, class, inner_ty)
             }
             LocalType::AccelerationStructure => Instruction::type_acceleration_structure(id),
             LocalType::RayQuery => Instruction::type_ray_query(id),
@@ -1579,6 +1580,9 @@ impl Writer {
             }
         }
 
+        // Note: we should be able to substitute `binding_array<Foo, 0>`,
+        // but there is still code that tries to register the pre-substituted type,
+        // and it is failing on 0.
         let mut substitute_inner_type_lookup = None;
         if let Some(ref res_binding) = global_variable.binding {
             self.decorate(id, Decoration::DescriptorSet, &[res_binding.group]);
@@ -1595,6 +1599,7 @@ impl Writer {
                         Some(LookupType::Local(LocalType::PointerToBindingArray {
                             base,
                             size: remapped_binding_array_size as u64,
+                            space: global_variable.space,
                         }))
                 }
             } else {
@@ -1635,7 +1640,13 @@ impl Writer {
             // a runtime-sized array. In this case, we need to decorate it with
             // Block.
             if let crate::AddressSpace::Storage { .. } = global_variable.space {
-                self.decorate(inner_type_id, Decoration::Block, &[]);
+                let decorated_id = match ir_module.types[global_variable.ty].inner {
+                    crate::TypeInner::BindingArray { base, .. } => {
+                        self.get_type_id(LookupType::Handle(base))
+                    }
+                    _ => inner_type_id,
+                };
+                self.decorate(decorated_id, Decoration::Block, &[]);
             }
             if substitute_inner_type_lookup.is_some() {
                 inner_type_id

src/proc/index.rs

@@ -390,7 +390,9 @@ impl crate::TypeInner {
                 match *base_inner {
                     Ti::Vector { size, .. } => size as _,
                     Ti::Matrix { columns, .. } => columns as _,
-                    Ti::Array { size, .. } => return size.to_indexable_length(module),
+                    Ti::Array { size, .. } | Ti::BindingArray { size, .. } => {
+                        return size.to_indexable_length(module)
+                    }
                     _ => return Err(IndexableLengthError::TypeNotIndexable),
                 }
             }

src/proc/typifier.rs

@@ -298,6 +298,7 @@ impl<'a> ResolveContext<'a> {
                             width,
                             space,
                         },
+                        Ti::BindingArray { base, .. } => Ti::Pointer { base, space },
                         ref other => {
                             log::error!("Access sub-type {:?}", other);
                             return Err(ResolveError::InvalidSubAccess {
@@ -401,6 +402,7 @@ impl<'a> ResolveContext<'a> {
                                 space,
                             }
                         }
+                        Ti::BindingArray { base, .. } => Ti::Pointer { base, space },
                         ref other => {
                             log::error!("Access index sub-type {:?}", other);
                             return Err(ResolveError::InvalidSubAccess {

src/valid/type.rs

@@ -630,7 +630,12 @@ impl super::Validator {
                 self.require_type_capability(Capabilities::RAY_QUERY)?;
                 TypeInfo::new(TypeFlags::DATA | TypeFlags::SIZED, Alignment::ONE)
             }
-            Ti::BindingArray { .. } => TypeInfo::new(TypeFlags::empty(), Alignment::ONE),
+            Ti::BindingArray { base, size: _ } => {
+                if base >= handle {
+                    return Err(TypeError::UnresolvedBase(base));
+                }
+                self.types[base.index()].clone()
+            }
         })
     }
 }

tests/in/binding-buffer-arrays.param.ron

@@ -0,0 +1,14 @@
+(
+	god_mode: false,
+	spv: (
+		version: (1, 1),
+		binding_map: {
+			(group: 0, binding: 0): (binding_array_size: Some(10)),
+		},
+	),
+	bounds_check_policies: (
+		index: ReadZeroSkipWrite,
+		buffer: ReadZeroSkipWrite,
+		image: ReadZeroSkipWrite,
+	)
+)

tests/in/binding-buffer-arrays.wgsl

@@ -0,0 +1,27 @@
+struct UniformIndex {
+    index: u32
+}
+
+struct Foo { x: u32 }
+@group(0) @binding(0)
+var<storage, read> storage_array: binding_array<Foo, 1>;
+@group(0) @binding(10)
+var<uniform> uni: UniformIndex;
+
+struct FragmentIn {
+    @location(0) index: u32,
+}
+
+@fragment
+fn main(fragment_in: FragmentIn) -> @location(0) u32 {
+    let uniform_index = uni.index;
+    let non_uniform_index = fragment_in.index;
+
+    var u1 = 0u;
+
+    u1 += storage_array[0].x;
+    u1 += storage_array[uniform_index].x;
+    u1 += storage_array[non_uniform_index].x;
+
+    return u1;
+}

tests/out/spv/binding-buffer-arrays.spvasm

@@ -0,0 +1,102 @@
+; SPIR-V
+; Version: 1.1
+; Generator: rspirv
+; Bound: 66
+OpCapability Shader
+OpExtension "SPV_KHR_storage_buffer_storage_class"
+%1 = OpExtInstImport "GLSL.std.450"
+OpMemoryModel Logical GLSL450
+OpEntryPoint Fragment %29 "main" %24 %27
+OpExecutionMode %29 OriginUpperLeft
+OpMemberDecorate %8 0 Offset 0
+OpMemberDecorate %9 0 Offset 0
+OpMemberDecorate %11 0 Offset 0
+OpDecorate %12 NonWritable
+OpDecorate %12 DescriptorSet 0
+OpDecorate %12 Binding 0
+OpDecorate %9 Block
+OpDecorate %16 DescriptorSet 0
+OpDecorate %16 Binding 10
+OpDecorate %17 Block
+OpMemberDecorate %17 0 Offset 0
+OpDecorate %24 Location 0
+OpDecorate %24 Flat
+OpDecorate %27 Location 0
+%2 = OpTypeVoid
+%4 = OpTypeInt 32 1
+%3 = OpConstant  %4  1
+%6 = OpTypeInt 32 0
+%5 = OpConstant  %6  0
+%7 = OpConstant  %4  0
+%8 = OpTypeStruct %6
+%9 = OpTypeStruct %6
+%10 = OpTypeArray %9 %3
+%11 = OpTypeStruct %6
+%15 = OpConstant  %6  10
+%14 = OpTypeArray %9 %15
+%13 = OpTypePointer StorageBuffer %14
+%12 = OpVariable  %13  StorageBuffer
+%17 = OpTypeStruct %8
+%18 = OpTypePointer Uniform %17
+%16 = OpVariable  %18  Uniform
+%20 = OpTypePointer Function %6
+%21 = OpConstantNull  %6
+%25 = OpTypePointer Input %6
+%24 = OpVariable  %25  Input
+%28 = OpTypePointer Output %6
+%27 = OpVariable  %28  Output
+%30 = OpTypeFunction %2
+%31 = OpTypePointer Uniform %8
+%33 = OpTypePointer StorageBuffer %10
+%35 = OpTypePointer Uniform %6
+%39 = OpTypePointer StorageBuffer %9
+%40 = OpTypePointer StorageBuffer %6
+%45 = OpConstant  %6  1
+%47 = OpTypeBool
+%49 = OpConstantNull  %6
+%58 = OpConstantNull  %6
+%29 = OpFunction  %2  None %30
+%22 = OpLabel
+%19 = OpVariable  %20  Function %21
+%26 = OpLoad  %6  %24
+%23 = OpCompositeConstruct  %11  %26
+%32 = OpAccessChain  %31  %16 %5
+OpBranch %34
+%34 = OpLabel
+%36 = OpAccessChain  %35  %32 %5
+%37 = OpLoad  %6  %36
+%38 = OpCompositeExtract  %6  %23 0
+OpStore %19 %5
+%41 = OpAccessChain  %40  %12 %5 %5
+%42 = OpLoad  %6  %41
+%43 = OpLoad  %6  %19
+%44 = OpIAdd  %6  %43 %42
+OpStore %19 %44
+%46 = OpULessThan  %47  %37 %45
+OpSelectionMerge %50 None
+OpBranchConditional %46 %51 %50
+%51 = OpLabel
+%48 = OpAccessChain  %40  %12 %37 %5
+%52 = OpLoad  %6  %48
+OpBranch %50
+%50 = OpLabel
+%53 = OpPhi  %6  %49 %34 %52 %51
+%54 = OpLoad  %6  %19
+%55 = OpIAdd  %6  %54 %53
+OpStore %19 %55
+%56 = OpULessThan  %47  %38 %45
+OpSelectionMerge %59 None
+OpBranchConditional %56 %60 %59
+%60 = OpLabel
+%57 = OpAccessChain  %40  %12 %38 %5
+%61 = OpLoad  %6  %57
+OpBranch %59
+%59 = OpLabel
+%62 = OpPhi  %6  %58 %50 %61 %60
+%63 = OpLoad  %6  %19
+%64 = OpIAdd  %6  %63 %62
+OpStore %19 %64
+%65 = OpLoad  %6  %19
+OpStore %27 %65
+OpReturn
+OpFunctionEnd

tests/out/wgsl/binding-buffer-arrays.wgsl

@@ -0,0 +1,36 @@
+struct UniformIndex {
+    index: u32,
+}
+
+struct Foo {
+    x: u32,
+}
+
+struct FragmentIn {
+    @location(0) index: u32,
+}
+
+@group(0) @binding(0) 
+var<storage> storage_array: binding_array<Foo,1>;
+@group(0) @binding(10) 
+var<uniform> uni: UniformIndex;
+
+@fragment 
+fn main(fragment_in: FragmentIn) -> @location(0) u32 {
+    var u1_: u32;
+
+    let uniform_index = uni.index;
+    let non_uniform_index = fragment_in.index;
+    u1_ = 0u;
+    let _e11 = storage_array[0].x;
+    let _e12 = u1_;
+    u1_ = (_e12 + _e11);
+    let _e17 = storage_array[uniform_index].x;
+    let _e18 = u1_;
+    u1_ = (_e18 + _e17);
+    let _e23 = storage_array[non_uniform_index].x;
+    let _e24 = u1_;
+    u1_ = (_e24 + _e23);
+    let _e26 = u1_;
+    return _e26;
+}

tests/snapshots.rs

@@ -554,6 +554,10 @@ fn convert_wgsl() {
             "binding-arrays",
             Targets::WGSL | Targets::HLSL | Targets::METAL | Targets::SPIRV,
         ),
+        (
+            "binding-buffer-arrays",
+            Targets::WGSL | Targets::SPIRV, //TODO: more backends, eventually merge into "binding-arrays"
+        ),
         ("resource-binding-map", Targets::METAL),
         ("multiview", Targets::SPIRV | Targets::GLSL | Targets::WGSL),
         ("multiview_webgl", Targets::GLSL),