Fix block layout to use std430 rules for StorageBuffer

The block layout validation was incorrectly applying std140 extended
alignment (16-byte rounding for arrays/structs) to all storage classes.
Std140 rules only apply to Uniform + Block decoration. StorageBuffer,
PushConstant, PhysicalStorageBuffer, Workgroup with Block, and Uniform
with BufferBlock all use std430 rules which have no 16-byte rounding.

This matches the C++ SPIRV-Tools behavior in validate_decorations.cpp
where blockRules (std140) is only true for Uniform + Block, and
bufferRules (std430) is used for all other combinations.

Author: LegNeato

rust/spirv-tools-core/src/validation/rules/block_layout.rs

@@ -48,6 +48,15 @@ impl ValidationRule for BlockLayoutRule {
                 continue;
             }
 
+            // Std140 extended alignment (16-byte rounding for arrays/structs) only
+            // applies to Uniform + Block decoration. All other combinations
+            // (StorageBuffer + Block, BufferBlock + Uniform, PushConstant + Block, etc.)
+            // use std430 rules which have no such rounding. This matches the C++
+            // SPIRV-Tools behavior in validate_decorations.cpp (blockRules vs bufferRules).
+            let is_uniform_block = block_info.decoration == BlockDecoration::Block
+                && block_info.storage_classes.contains(&StorageClass::Uniform);
+            let extended_alignment = is_uniform_block && !relax_layout;
+
             let Some(struct_inst) = ctx.definitions.get(&struct_id) else {
                 continue;
             };
@@ -79,13 +88,12 @@ impl ValidationRule for BlockLayoutRule {
                 let Some(member_inst) = ctx.definitions.get(&member_result_id) else {
                     continue;
                 };
-                // Pass relax_layout to skip std140's 16-byte extended alignment rule
-                // With relaxed or scalar layout, arrays/structs align to their natural alignment
                 let Some(alignment) = type_alignment(
                     member_type_id,
                     ctx.definitions,
                     &mut HashSet::new(),
                     relax_layout,
+                    extended_alignment,
                 ) else {
                     continue;
                 };
@@ -507,21 +515,29 @@ fn type_alignment(
     definitions: &HashMap<ResultId, rspirv::dr::Instruction>,
     visiting: &mut HashSet<TypeId>,
     scalar_layout: bool,
+    extended_alignment: bool,
 ) -> Option<u32> {
-    type_alignment_extended(ty, definitions, visiting, scalar_layout, false)
+    type_alignment_extended(ty, definitions, visiting, scalar_layout, false, extended_alignment)
 }
 
 /// Calculates type alignment with optional extended alignment for std140 rules.
 ///
-/// In std140:
+/// In std140 (Uniform + Block):
 /// - Arrays and structs have their base alignment rounded up to 16 bytes
 /// - This is called "extended alignment"
+///
+/// In std430 (StorageBuffer + Block, BufferBlock + Uniform, PushConstant + Block, etc.):
+/// - No 16-byte rounding is applied
+///
+/// The `extended_alignment` parameter controls whether the 16-byte rounding applies.
+/// It should be `true` only for std140 (Uniform + Block) when not using relaxed/scalar layout.
 fn type_alignment_extended(
     ty: TypeId,
     definitions: &HashMap<ResultId, rspirv::dr::Instruction>,
     visiting: &mut HashSet<TypeId>,
     scalar_layout: bool,
     use_extended: bool,
+    extended_alignment: bool,
 ) -> Option<u32> {
     if !visiting.insert(ty) {
         return None;
@@ -536,7 +552,7 @@ fn type_alignment_extended(
             let (elem, count) = vector_info(inst);
             let (elem, count) = (elem?, count?);
             let elem_align =
-                type_alignment_extended(elem, definitions, visiting, scalar_layout, false)?;
+                type_alignment_extended(elem, definitions, visiting, scalar_layout, false, extended_alignment)?;
             if scalar_layout {
                 Some(elem_align)
             } else {
@@ -549,17 +565,16 @@ fn type_alignment_extended(
             // Matrix alignment follows its column vector alignment.
             let (column, _) = matrix_info(inst);
             let column = column?;
-            type_alignment_extended(column, definitions, visiting, scalar_layout, use_extended)
+            type_alignment_extended(column, definitions, visiting, scalar_layout, use_extended, extended_alignment)
         }
         Op::TypeArray | Op::TypeRuntimeArray => {
             let elem = inst.operands.first().and_then(|op| match op {
                 rspirv::dr::Operand::IdRef(id) => TypeId::try_from(*id).ok(),
                 _ => None,
             })?;
-            // In std140, array element alignment is rounded up to 16 bytes (extended alignment)
             let base_align =
-                type_alignment_extended(elem, definitions, visiting, scalar_layout, true)?;
-            if use_extended && !scalar_layout {
+                type_alignment_extended(elem, definitions, visiting, scalar_layout, true, extended_alignment)?;
+            if use_extended && extended_alignment && !scalar_layout {
                 Some(round_up(base_align, 16))
             } else {
                 Some(base_align)
@@ -573,11 +588,10 @@ fn type_alignment_extended(
                     _ => return None,
                 };
                 let align =
-                    type_alignment_extended(ty, definitions, visiting, scalar_layout, true)?;
+                    type_alignment_extended(ty, definitions, visiting, scalar_layout, true, extended_alignment)?;
                 max_align = max_align.max(align);
             }
-            // In std140, struct alignment is rounded up to 16 bytes (extended alignment)
-            if use_extended && !scalar_layout {
+            if use_extended && extended_alignment && !scalar_layout {
                 Some(round_up(max_align, 16))
             } else {
                 Some(max_align)
@@ -597,7 +611,7 @@ fn vector_scalar_alignment(
         rspirv::dr::Operand::IdRef(id) => TypeId::try_from(*id).ok(),
         _ => None,
     })?;
-    type_alignment(elem, definitions, &mut HashSet::new(), true)
+    type_alignment(elem, definitions, &mut HashSet::new(), true, false)
 }
 
 fn vector_info(inst: &rspirv::dr::Instruction) -> (Option<TypeId>, Option<u32>) {

rust/spirv-tools-core/src/validation/tests/mod.rs

@@ -14427,6 +14427,62 @@ fn array_stride_must_align_to_element() {
     assert!(matches!(err, ValidationError::InvalidBlockLayout { .. }));
 }
 #[test]
+fn storage_buffer_array_stride_uses_std430_no_extended_alignment() {
+    // StorageBuffer + Block uses std430 rules: arrays do NOT get 16-byte
+    // extended alignment. An array of uint[2] with stride 8 should be valid
+    // because the element alignment is 4, and 8 % 4 == 0.
+    let text = [
+        "OpCapability Shader",
+        "OpMemoryModel Logical GLSL450",
+        "OpDecorate %struct Block",
+        "OpDecorate %var DescriptorSet 0",
+        "OpDecorate %var Binding 0",
+        "OpMemberDecorate %struct 0 Offset 0",
+        "OpDecorate %inner_arr ArrayStride 4",
+        "OpDecorate %outer_arr ArrayStride 8",
+        "%int = OpTypeInt 32 0",
+        "%two = OpConstant %int 2",
+        "%inner_arr = OpTypeArray %int %two",
+        "%outer_arr = OpTypeArray %inner_arr %two",
+        "%struct = OpTypeStruct %outer_arr",
+        "%ptr = OpTypePointer StorageBuffer %struct",
+        "%var = OpVariable %ptr StorageBuffer",
+    ]
+    .join("\n");
+    text.as_str()
+        .validate(TargetEnv::Universal1_6)
+        .expect("StorageBuffer uses std430 rules where array stride 8 is valid");
+}
+#[test]
+fn uniform_block_array_stride_requires_std140_extended_alignment() {
+    // Uniform + Block uses std140 rules: arrays get 16-byte extended alignment.
+    // An array of uint[2] with stride 8 should be rejected because std140
+    // rounds the array alignment up to 16, and 8 % 16 != 0.
+    let text = [
+        "OpCapability Shader",
+        "OpMemoryModel Logical GLSL450",
+        "OpDecorate %struct Block",
+        "OpDecorate %var DescriptorSet 0",
+        "OpDecorate %var Binding 0",
+        "OpMemberDecorate %struct 0 Offset 0",
+        "OpDecorate %inner_arr ArrayStride 4",
+        "OpDecorate %outer_arr ArrayStride 8",
+        "%int = OpTypeInt 32 0",
+        "%two = OpConstant %int 2",
+        "%inner_arr = OpTypeArray %int %two",
+        "%outer_arr = OpTypeArray %inner_arr %two",
+        "%struct = OpTypeStruct %outer_arr",
+        "%ptr = OpTypePointer Uniform %struct",
+        "%var = OpVariable %ptr Uniform",
+    ]
+    .join("\n");
+    let err = text
+        .as_str()
+        .validate(TargetEnv::Universal1_6)
+        .expect_err("Uniform + Block uses std140 where array stride 8 is not aligned to 16");
+    assert!(matches!(err, ValidationError::InvalidBlockLayout { .. }));
+}
+#[test]
 fn vector_straddle_rejected_under_relax() {
     let text = [
         "OpCapability Shader",