fix(msl-out): emit and init struct member padding always

Resolves
[`gfx-rs/wgpu`#4701](#4701).

Author: ErichDonGubler

naga/CHANGELOG.md

@@ -79,6 +79,7 @@ For changelogs after v0.14, see [the wgpu changelog](../CHANGELOG.md).
 
 - Add and fix minimum Metal version checks for optional functionality. ([#2486](https://github.com/gfx-rs/naga/pull/2486)) **@teoxoy**
 - Make varyings' struct members unique. ([#2521](https://github.com/gfx-rs/naga/pull/2521)) **@evahop**
+- Emit and init `struct` member padding always ([#4701](https://github.com/gfx-rs/wgpu/pull/4701)) **@ErichDonGubler**
 
 #### GLSL-OUT
 

naga/src/back/msl/writer.rs

@@ -357,11 +357,6 @@ fn should_pack_struct_member(
     module: &crate::Module,
 ) -> Option<crate::Scalar> {
     let member = &members[index];
-    //Note: this is imperfect - the same structure can be used for host-shared
-    // things, where packed float would matter.
-    if member.binding.is_some() {
-        return None;
-    }
 
     let ty_inner = &module.types[member.ty].inner;
     let last_offset = member.offset + ty_inner.size(module.to_ctx());
@@ -3306,7 +3301,7 @@ impl<W: Write> Writer<W> {
                     let mut last_offset = 0;
                     for (index, member) in members.iter().enumerate() {
                         // quick and dirty way to figure out if we need this...
-                        if member.binding.is_none() && member.offset > last_offset {
+                        if member.offset > last_offset {
                             self.struct_member_pads.insert((handle, index as u32));
                             let pad = member.offset - last_offset;
                             writeln!(self.out, "{}char _pad{}[{}];", back::INDENT, index, pad)?;
@@ -4273,6 +4268,13 @@ impl<W: Write> Writer<W> {
                             if member_index != 0 {
                                 write!(self.out, ", ")?;
                             }
+                            // insert padding initialization, if needed
+                            if self
+                                .struct_member_pads
+                                .contains(&(arg.ty, member_index as u32))
+                            {
+                                write!(self.out, "{{}}, ")?;
+                            }
                             if let Some(crate::Binding::Location { .. }) = member.binding {
                                 write!(self.out, "{varyings_member_name}.")?;
                             }

naga/tests/in/struct-layout.wgsl

@@ -0,0 +1,43 @@
+// Create several type definitions to test `align` and `size` layout.
+
+struct NoPadding {
+	@location(0)
+	v3: vec3f, // align 16, size 12; no start padding needed
+	@location(1)
+	f3: f32, // align 4, size 4; no start padding needed
+}
+// struct NoPaddingNoBindings {
+//	v3: vec3f,
+//	f3: f32,
+// }
+@fragment
+fn no_padding_frag(input: NoPadding) -> @location(0) vec4f {
+	_ = input;
+	return vec4f(0.0);
+}
+@vertex
+fn no_padding_vert(input: NoPadding) -> @builtin(position) vec4f {
+	_ = input;
+	return vec4f(0.0);
+}
+
+struct NeedsPadding {
+	@location(0) f3_forces_padding: f32, // align 4, size 4; no start padding needed
+	@location(1) v3_needs_padding: vec3f, // align 16, size 12; needs 12 bytes of padding
+	@location(2) f3: f32, // align 4, size 4; no start padding needed
+}
+// struct NeedsPaddingNoBindings {
+//	f3_forces_padding: f32,
+//	v3_needs_padding: vec3f,
+//	f3: f32,
+// }
+@fragment
+fn needs_padding_frag(input: NeedsPadding) -> @location(0) vec4f {
+	_ = input;
+	return vec4f(0.0);
+}
+@vertex
+fn needs_padding_vert(input: NeedsPadding) -> @builtin(position) vec4f {
+	_ = input;
+	return vec4f(0.0);
+}

naga/tests/out/msl/quad.msl

@@ -6,6 +6,7 @@ using metal::uint;
 
 struct VertexOutput {
     metal::float2 uv;
+    char _pad1[8];
     metal::float4 position;
 };
 constant float c_scale = 1.2;
@@ -23,7 +24,7 @@ vertex vert_mainOutput vert_main(
 ) {
     const auto pos = varyings.pos;
     const auto uv = varyings.uv;
-    const auto _tmp = VertexOutput {uv, metal::float4(c_scale * pos, 0.0, 1.0)};
+    const auto _tmp = VertexOutput {uv, {}, metal::float4(c_scale * pos, 0.0, 1.0)};
     return vert_mainOutput { _tmp.uv, _tmp.position };
 }