tint/msl: Preserve trailing vec3 padding

In order to preserve padding properly for MSL, we need to use its
packed_vec type for all vec3 types in storage buffers, not just struct
members. This commit includes a complete rewrite of the PackedVec3
transform to achieve this. The key details are:

* An internal `__packed_vec3<>` type was added, which corresponds to a
  `type::Vector` with an additional flag to indicate that it will be
  emitted as packed vector.

* The `PackedVec3` transform replaces all vec3 types used in
  host-shareable address spaces with the internal `__packed_vec3`
  type. This includes vec3 types that appear as the store type of a
  pointer.

* When used as an array element, these `__packed_vec3` types are
  wrapped in a struct that contains a single `__packed_vec3`
  member. This allows us to add an `@align()` attribute that ensures
  that `array<vec3<T>>` still has the correct array element stride.

* When the `vec3<T>` appears as a struct member in the input program,
  we apply the `@align()` to that member to ensure that we do not
  change its offset.

* Matrix types with three rows that are used in memory are replaced
  with an array of columns, where each column uses a `__packed_vec3`
  inside an aligned wrapper structure as above.

* Accesses to host-shareable memory that involve any of these types
  invoke a "pack" or "unpack" helper function to convert them to the
  equivalent type that uses `__packed_vec3` or a regular `vec3` as
  required.

* The `chromium_internal_relaxed_uniform_layout` extension is used to
  avoid issues where modifying a type in the uniform address space
  triggers stricter layout validation rules.

Bug: tint:1571
Fixed: tint:1837
Change-Id: Idaf2da2f5bcb2be00c85ec657edfb614186476bb
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/121200
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: James Price <jrprice@google.com>
Kokoro: Kokoro <noreply+kokoro@google.com>

test/tint/expressions/binary/mul/mat3x2-vec3/f16.wgsl.expected.msl

@@ -14,14 +14,19 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
+struct S_tint_packed_vec3 {
   /* 0x0000 */ half3x2 tint_symbol;
   /* 0x000c */ tint_array<int8_t, 4> tint_pad;
   /* 0x0010 */ packed_half3 vector;
   /* 0x0016 */ tint_array<int8_t, 2> tint_pad_1;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
+struct S {
+  half3x2 tint_symbol;
+  half3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
   half2 const x = ((*(tint_symbol_2)).tint_symbol * half3((*(tint_symbol_2)).vector));
   return;
 }

test/tint/expressions/binary/mul/mat3x2-vec3/f32.wgsl.expected.msl

@@ -14,14 +14,19 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
+struct S_tint_packed_vec3 {
   /* 0x0000 */ float3x2 tint_symbol;
   /* 0x0018 */ tint_array<int8_t, 8> tint_pad;
   /* 0x0020 */ packed_float3 vector;
   /* 0x002c */ tint_array<int8_t, 4> tint_pad_1;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
+struct S {
+  float3x2 tint_symbol;
+  float3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
   float2 const x = ((*(tint_symbol_2)).tint_symbol * float3((*(tint_symbol_2)).vector));
   return;
 }

test/tint/expressions/binary/mul/mat3x3-vec3/f16.wgsl.expected.msl

@@ -14,14 +14,32 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
-  /* 0x0000 */ half3x3 tint_symbol;
-  /* 0x0018 */ packed_half3 vector;
-  /* 0x001e */ tint_array<int8_t, 2> tint_pad;
+struct tint_packed_vec3_f16_array_element {
+  /* 0x0000 */ packed_half3 elements;
+  /* 0x0006 */ tint_array<int8_t, 2> tint_pad;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
-  half3 const x = ((*(tint_symbol_2)).tint_symbol * half3((*(tint_symbol_2)).vector));
+struct S_tint_packed_vec3 {
+  /* 0x0000 */ tint_array<tint_packed_vec3_f16_array_element, 3> tint_symbol;
+  /* 0x0018 */ packed_half3 vector;
+  /* 0x001e */ tint_array<int8_t, 2> tint_pad_1;
+};
+
+half3x3 tint_unpack_vec3_in_composite(tint_array<tint_packed_vec3_f16_array_element, 3> in) {
+  half3x3 result = half3x3(0.0h);
+  for(uint i = 0u; (i < 3u); i = (i + 1u)) {
+    result[i] = half3(in[i].elements);
+  }
+  return result;
+}
+
+struct S {
+  half3x3 tint_symbol;
+  half3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
+  half3 const x = (tint_unpack_vec3_in_composite((*(tint_symbol_2)).tint_symbol) * half3((*(tint_symbol_2)).vector));
   return;
 }
 

test/tint/expressions/binary/mul/mat3x3-vec3/f32.wgsl.expected.msl

@@ -14,14 +14,32 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
-  /* 0x0000 */ float3x3 tint_symbol;
-  /* 0x0030 */ packed_float3 vector;
-  /* 0x003c */ tint_array<int8_t, 4> tint_pad;
+struct tint_packed_vec3_f32_array_element {
+  /* 0x0000 */ packed_float3 elements;
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
-  float3 const x = ((*(tint_symbol_2)).tint_symbol * float3((*(tint_symbol_2)).vector));
+struct S_tint_packed_vec3 {
+  /* 0x0000 */ tint_array<tint_packed_vec3_f32_array_element, 3> tint_symbol;
+  /* 0x0030 */ packed_float3 vector;
+  /* 0x003c */ tint_array<int8_t, 4> tint_pad_1;
+};
+
+float3x3 tint_unpack_vec3_in_composite(tint_array<tint_packed_vec3_f32_array_element, 3> in) {
+  float3x3 result = float3x3(0.0f);
+  for(uint i = 0u; (i < 3u); i = (i + 1u)) {
+    result[i] = float3(in[i].elements);
+  }
+  return result;
+}
+
+struct S {
+  float3x3 tint_symbol;
+  float3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
+  float3 const x = (tint_unpack_vec3_in_composite((*(tint_symbol_2)).tint_symbol) * float3((*(tint_symbol_2)).vector));
   return;
 }
 

test/tint/expressions/binary/mul/vec3-mat3x3/f16.wgsl.expected.msl

@@ -14,14 +14,32 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
-  /* 0x0000 */ half3x3 tint_symbol;
-  /* 0x0018 */ packed_half3 vector;
-  /* 0x001e */ tint_array<int8_t, 2> tint_pad;
+struct tint_packed_vec3_f16_array_element {
+  /* 0x0000 */ packed_half3 elements;
+  /* 0x0006 */ tint_array<int8_t, 2> tint_pad;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
-  half3 const x = (half3((*(tint_symbol_2)).vector) * (*(tint_symbol_2)).tint_symbol);
+struct S_tint_packed_vec3 {
+  /* 0x0000 */ tint_array<tint_packed_vec3_f16_array_element, 3> tint_symbol;
+  /* 0x0018 */ packed_half3 vector;
+  /* 0x001e */ tint_array<int8_t, 2> tint_pad_1;
+};
+
+half3x3 tint_unpack_vec3_in_composite(tint_array<tint_packed_vec3_f16_array_element, 3> in) {
+  half3x3 result = half3x3(0.0h);
+  for(uint i = 0u; (i < 3u); i = (i + 1u)) {
+    result[i] = half3(in[i].elements);
+  }
+  return result;
+}
+
+struct S {
+  half3x3 tint_symbol;
+  half3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
+  half3 const x = (half3((*(tint_symbol_2)).vector) * tint_unpack_vec3_in_composite((*(tint_symbol_2)).tint_symbol));
   return;
 }
 

test/tint/expressions/binary/mul/vec3-mat3x3/f32.wgsl.expected.msl

@@ -14,14 +14,32 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
-  /* 0x0000 */ float3x3 tint_symbol;
-  /* 0x0030 */ packed_float3 vector;
-  /* 0x003c */ tint_array<int8_t, 4> tint_pad;
+struct tint_packed_vec3_f32_array_element {
+  /* 0x0000 */ packed_float3 elements;
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
-  float3 const x = (float3((*(tint_symbol_2)).vector) * (*(tint_symbol_2)).tint_symbol);
+struct S_tint_packed_vec3 {
+  /* 0x0000 */ tint_array<tint_packed_vec3_f32_array_element, 3> tint_symbol;
+  /* 0x0030 */ packed_float3 vector;
+  /* 0x003c */ tint_array<int8_t, 4> tint_pad_1;
+};
+
+float3x3 tint_unpack_vec3_in_composite(tint_array<tint_packed_vec3_f32_array_element, 3> in) {
+  float3x3 result = float3x3(0.0f);
+  for(uint i = 0u; (i < 3u); i = (i + 1u)) {
+    result[i] = float3(in[i].elements);
+  }
+  return result;
+}
+
+struct S {
+  float3x3 tint_symbol;
+  float3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
+  float3 const x = (float3((*(tint_symbol_2)).vector) * tint_unpack_vec3_in_composite((*(tint_symbol_2)).tint_symbol));
   return;
 }
 

test/tint/expressions/binary/mul/vec3-mat4x3/f16.wgsl.expected.msl

@@ -14,14 +14,32 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
-  /* 0x0000 */ half4x3 tint_symbol;
-  /* 0x0020 */ packed_half3 vector;
-  /* 0x0026 */ tint_array<int8_t, 2> tint_pad;
+struct tint_packed_vec3_f16_array_element {
+  /* 0x0000 */ packed_half3 elements;
+  /* 0x0006 */ tint_array<int8_t, 2> tint_pad;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
-  half4 const x = (half3((*(tint_symbol_2)).vector) * (*(tint_symbol_2)).tint_symbol);
+struct S_tint_packed_vec3 {
+  /* 0x0000 */ tint_array<tint_packed_vec3_f16_array_element, 4> tint_symbol;
+  /* 0x0020 */ packed_half3 vector;
+  /* 0x0026 */ tint_array<int8_t, 2> tint_pad_1;
+};
+
+half4x3 tint_unpack_vec3_in_composite(tint_array<tint_packed_vec3_f16_array_element, 4> in) {
+  half4x3 result = half4x3(0.0h);
+  for(uint i = 0u; (i < 4u); i = (i + 1u)) {
+    result[i] = half3(in[i].elements);
+  }
+  return result;
+}
+
+struct S {
+  half4x3 tint_symbol;
+  half3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
+  half4 const x = (half3((*(tint_symbol_2)).vector) * tint_unpack_vec3_in_composite((*(tint_symbol_2)).tint_symbol));
   return;
 }
 

test/tint/expressions/binary/mul/vec3-mat4x3/f32.wgsl.expected.msl

@@ -14,14 +14,32 @@ struct tint_array {
     T elements[N];
 };
 
-struct S {
-  /* 0x0000 */ float4x3 tint_symbol;
-  /* 0x0040 */ packed_float3 vector;
-  /* 0x004c */ tint_array<int8_t, 4> tint_pad;
+struct tint_packed_vec3_f32_array_element {
+  /* 0x0000 */ packed_float3 elements;
+  /* 0x000c */ tint_array<int8_t, 4> tint_pad;
 };
 
-fragment void tint_symbol_1(const constant S* tint_symbol_2 [[buffer(0)]]) {
-  float4 const x = (float3((*(tint_symbol_2)).vector) * (*(tint_symbol_2)).tint_symbol);
+struct S_tint_packed_vec3 {
+  /* 0x0000 */ tint_array<tint_packed_vec3_f32_array_element, 4> tint_symbol;
+  /* 0x0040 */ packed_float3 vector;
+  /* 0x004c */ tint_array<int8_t, 4> tint_pad_1;
+};
+
+float4x3 tint_unpack_vec3_in_composite(tint_array<tint_packed_vec3_f32_array_element, 4> in) {
+  float4x3 result = float4x3(0.0f);
+  for(uint i = 0u; (i < 4u); i = (i + 1u)) {
+    result[i] = float3(in[i].elements);
+  }
+  return result;
+}
+
+struct S {
+  float4x3 tint_symbol;
+  float3 vector;
+};
+
+fragment void tint_symbol_1(const constant S_tint_packed_vec3* tint_symbol_2 [[buffer(0)]]) {
+  float4 const x = (float3((*(tint_symbol_2)).vector) * tint_unpack_vec3_in_composite((*(tint_symbol_2)).tint_symbol));
   return;
 }